@launchdarkly/js-sdk-common 2.9.0 → 2.10.1-beta.1

package/dist/esm/index.mjs

@@ -0,0 +1,2432 @@
+/**
+ * Converts a literal to a ref string.
+ * @param value
+ * @returns An escaped literal which can be used as a ref.
+ */
+function toRefString(value) {
+    return `/${value.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+}
+/**
+ * Produce a literal from a ref component.
+ * @param ref
+ * @returns A literal version of the ref.
+ */
+function unescape(ref) {
+    return ref.indexOf('~') ? ref.replace(/~1/g, '/').replace(/~0/g, '~') : ref;
+}
+function getComponents(reference) {
+    const referenceWithoutPrefix = reference.startsWith('/') ? reference.substring(1) : reference;
+    return referenceWithoutPrefix.split('/').map((component) => unescape(component));
+}
+function isLiteral(reference) {
+    return !reference.startsWith('/');
+}
+function validate(reference) {
+    return !reference.match(/\/\/|(^\/.*~[^0|^1])|~$/);
+}
+class AttributeReference {
+    /**
+     * Take an attribute reference string, or literal string, and produce
+     * an attribute reference.
+     *
+     * Legacy user objects would have been created with names not
+     * references. So, in that case, we need to use them as a component
+     * without escaping them.
+     *
+     * e.g. A user could contain a custom attribute of `/a` which would
+     * become the literal `a` if treated as a reference. Which would cause
+     * it to no longer be redacted.
+     * @param refOrLiteral The attribute reference string or literal string.
+     * @param literal it true the value should be treated as a literal.
+     */
+    constructor(refOrLiteral, literal = false) {
+        if (!literal) {
+            this.redactionName = refOrLiteral;
+            if (refOrLiteral === '' || refOrLiteral === '/' || !validate(refOrLiteral)) {
+                this.isValid = false;
+                this._components = [];
+                return;
+            }
+            if (isLiteral(refOrLiteral)) {
+                this._components = [refOrLiteral];
+            }
+            else if (refOrLiteral.indexOf('/', 1) < 0) {
+                this._components = [unescape(refOrLiteral.slice(1))];
+            }
+            else {
+                this._components = getComponents(refOrLiteral);
+            }
+            // The items inside of '_meta' are not intended to be addressable.
+            // Excluding it as a valid reference means that we can make it non-addressable
+            // without having to copy all the attributes out of the context object
+            // provided by the user.
+            if (this._components[0] === '_meta') {
+                this.isValid = false;
+            }
+            else {
+                this.isValid = true;
+            }
+        }
+        else {
+            const literalVal = refOrLiteral;
+            this._components = [literalVal];
+            this.isValid = literalVal !== '';
+            // Literals which start with '/' need escaped to prevent ambiguity.
+            this.redactionName = literalVal.startsWith('/') ? toRefString(literalVal) : literalVal;
+        }
+    }
+    get(target) {
+        const { _components: components, isValid } = this;
+        if (!isValid) {
+            return undefined;
+        }
+        let current = target;
+        // This doesn't use a range based for loops, because those use generators.
+        // See `no-restricted-syntax`.
+        // It also doesn't use a collection method because this logic is more
+        // straightforward with a loop.
+        for (let index = 0; index < components.length; index += 1) {
+            const component = components[index];
+            if (current !== null &&
+                current !== undefined &&
+                // See https://eslint.org/docs/rules/no-prototype-builtins
+                Object.prototype.hasOwnProperty.call(current, component) &&
+                typeof current === 'object' &&
+                // We do not want to allow indexing into an array.
+                !Array.isArray(current)) {
+                current = current[component];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    getComponent(depth) {
+        return this._components[depth];
+    }
+    get depth() {
+        return this._components.length;
+    }
+    get isKind() {
+        return this._components.length === 1 && this._components[0] === 'kind';
+    }
+    compare(other) {
+        return (this.depth === other.depth &&
+            this._components.every((value, index) => value === other.getComponent(index)));
+    }
+}
+/**
+ * For use as invalid references when deserializing Flag/Segment data.
+ */
+AttributeReference.InvalidReference = new AttributeReference('');
+
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+/**
+ * Validate a factory or instance.
+ */
+class FactoryOrInstance {
+    is(factoryOrInstance) {
+        if (Array.isArray(factoryOrInstance)) {
+            return false;
+        }
+        const anyFactory = factoryOrInstance;
+        const typeOfFactory = typeof anyFactory;
+        return typeOfFactory === 'function' || typeOfFactory === 'object';
+    }
+    getType() {
+        return 'factory method or object';
+    }
+}
+/**
+ * Validate a basic type.
+ */
+class Type {
+    constructor(typeName, example) {
+        this._typeName = typeName;
+        this.typeOf = typeof example;
+    }
+    is(u) {
+        if (Array.isArray(u)) {
+            return false;
+        }
+        return typeof u === this.typeOf;
+    }
+    getType() {
+        return this._typeName;
+    }
+}
+/**
+ * Validate an array of the specified type.
+ *
+ * This does not validate instances of types. All class instances
+ * of classes will simply objects.
+ */
+class TypeArray {
+    constructor(typeName, example) {
+        this._typeName = typeName;
+        this.typeOf = typeof example;
+    }
+    is(u) {
+        if (Array.isArray(u)) {
+            if (u.length > 0) {
+                return u.every((val) => typeof val === this.typeOf);
+            }
+            return true;
+        }
+        return false;
+    }
+    getType() {
+        return this._typeName;
+    }
+}
+/**
+ * Validate a value is a number and is greater or eval than a minimum.
+ */
+class NumberWithMinimum extends Type {
+    constructor(min) {
+        super(`number with minimum value of ${min}`, 0);
+        this.min = min;
+    }
+    is(u) {
+        return typeof u === this.typeOf && u >= this.min;
+    }
+}
+/**
+ * Validate a value is a string and it matches the given expression.
+ */
+class StringMatchingRegex extends Type {
+    constructor(expression) {
+        super(`string matching ${expression}`, '');
+        this.expression = expression;
+    }
+    is(u) {
+        return typeof u === 'string' && !!u.match(this.expression);
+    }
+}
+/**
+ * Validate a value is a function.
+ */
+class Function {
+    is(u) {
+        // We cannot inspect the parameters and there isn't really
+        // a generic function type we can instantiate.
+        // So the type guard is here just to make TS comfortable
+        // calling something after using this guard.
+        return typeof u === 'function';
+    }
+    getType() {
+        return 'function';
+    }
+}
+class NullableBoolean {
+    is(u) {
+        return typeof u === 'boolean' || typeof u === 'undefined' || u === null;
+    }
+    getType() {
+        return 'boolean | undefined | null';
+    }
+}
+// Our reference SDK, Go, parses date/time strings with the time.RFC3339Nano format.
+// This regex should match strings that are valid in that format, and no others.
+// Acceptable:
+//   2019-10-31T23:59:59Z, 2019-10-31T23:59:59.100Z,
+//   2019-10-31T23:59:59-07, 2019-10-31T23:59:59-07:00, etc.
+// Unacceptable: no "T", no time zone designation
+const DATE_REGEX = /^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d\d*)?(Z|[-+]\d\d(:\d\d)?)/;
+/**
+ * Validate a value is a date. Values which are numbers are treated as dates and any string
+ * which if compliant with `time.RFC3339Nano` is a date.
+ */
+class DateValidator {
+    is(u) {
+        return typeof u === 'number' || (typeof u === 'string' && DATE_REGEX.test(u));
+    }
+    getType() {
+        return 'date';
+    }
+}
+/**
+ * Validates that a string is a valid kind.
+ */
+class KindValidator extends StringMatchingRegex {
+    constructor() {
+        super(/^(\w|\.|-)+$/);
+    }
+    is(u) {
+        return super.is(u) && u !== 'kind';
+    }
+}
+/**
+ * A set of standard type validators.
+ */
+class TypeValidators {
+    static createTypeArray(typeName, example) {
+        return new TypeArray(typeName, example);
+    }
+    static numberWithMin(min) {
+        return new NumberWithMinimum(min);
+    }
+    static stringMatchingRegex(expression) {
+        return new StringMatchingRegex(expression);
+    }
+}
+TypeValidators.String = new Type('string', '');
+TypeValidators.Number = new Type('number', 0);
+TypeValidators.ObjectOrFactory = new FactoryOrInstance();
+TypeValidators.Object = new Type('object', {});
+TypeValidators.StringArray = new TypeArray('string[]', '');
+TypeValidators.Boolean = new Type('boolean', true);
+TypeValidators.Function = new Function();
+TypeValidators.Date = new DateValidator();
+TypeValidators.Kind = new KindValidator();
+TypeValidators.NullableBoolean = new NullableBoolean();
+
+/**
+ * Check if a context is a single kind context.
+ * @param context
+ * @returns true if the context is a single kind context.
+ */
+function isSingleKind(context) {
+    if ('kind' in context) {
+        return TypeValidators.String.is(context.kind) && context.kind !== 'multi';
+    }
+    return false;
+}
+/**
+ * Check if a context is a multi-kind context.
+ * @param context
+ * @returns true if it is a multi-kind context.
+ */
+function isMultiKind(context) {
+    if ('kind' in context) {
+        return TypeValidators.String.is(context.kind) && context.kind === 'multi';
+    }
+    return false;
+}
+/**
+ * Check if a context is a legacy user context.
+ * @param context
+ * @returns true if it is a legacy user context.
+ */
+function isLegacyUser(context) {
+    return !('kind' in context) || context.kind === null || context.kind === undefined;
+}
+
+// The general strategy for the context is to transform the passed in context
+// as little as possible. We do convert the legacy users to a single kind
+// context, but we do not translate all passed contexts into a rigid structure.
+// The context will have to be copied for events, but we want to avoid any
+// copying that we can.
+// So we validate that the information we are given is correct, and then we
+// just proxy calls with a nicely typed interface.
+// This is to reduce work on the hot-path. Later, for event processing, deeper
+// cloning of the context will be done.
+// When no kind is specified, then this kind will be used.
+const DEFAULT_KIND = 'user';
+// The API allows for calling with an `LDContext` which is
+// `LDUser | LDSingleKindContext | LDMultiKindContext`. When ingesting a context
+// first the type must be determined to allow us to put it into a consistent type.
+/**
+ * The partial URL encoding is needed because : is a valid character in context keys.
+ *
+ * Partial encoding is the replacement of all colon (:) characters with the URL
+ * encoded equivalent (%3A) and all percent (%) characters with the URL encoded
+ * equivalent (%25).
+ * @param key The key to encode.
+ * @returns Partially URL encoded key.
+ */
+function encodeKey(key) {
+    if (key.includes('%') || key.includes(':')) {
+        return key.replace(/%/g, '%25').replace(/:/g, '%3A');
+    }
+    return key;
+}
+/**
+ * Check if the given value is a LDContextCommon.
+ * @param kindOrContext
+ * @returns true if it is an LDContextCommon
+ *
+ * Due to a limitation in the expressiveness of these highly polymorphic types any field
+ * in a multi-kind context can either be a context or 'kind'. So we need to re-assure
+ * the compiler that it isn't the word multi.
+ *
+ * Because we do not allow top level values in a multi-kind context we can validate
+ * that as well.
+ */
+function isContextCommon(kindOrContext) {
+    return kindOrContext && TypeValidators.Object.is(kindOrContext);
+}
+/**
+ * Validate a context kind.
+ * @param kind
+ * @returns true if the kind is valid.
+ */
+function validKind(kind) {
+    return TypeValidators.Kind.is(kind);
+}
+/**
+ * Validate a context key.
+ * @param key
+ * @returns true if the key is valid.
+ */
+function validKey(key) {
+    return TypeValidators.String.is(key) && key !== '';
+}
+function processPrivateAttributes(privateAttributes, literals = false) {
+    if (privateAttributes) {
+        return privateAttributes.map((privateAttribute) => new AttributeReference(privateAttribute, literals));
+    }
+    return [];
+}
+function defined(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Convert a legacy user to a single kind context.
+ * @param user
+ * @returns A single kind context.
+ */
+function legacyToSingleKind(user) {
+    const singleKindContext = {
+        // Key was coerced to a string for eval and events, so we can do that up-front.
+        ...(user.custom || []),
+        kind: 'user',
+        key: String(user.key),
+    };
+    // For legacy users we never established a difference between null
+    // and undefined for inputs. Because anonymous can be used in evaluations
+    // we would want it to not possibly match true/false unless defined.
+    // Which is different than coercing a null/undefined anonymous as `false`.
+    if (defined(user.anonymous)) {
+        const anonymous = !!user.anonymous;
+        delete singleKindContext.anonymous;
+        singleKindContext.anonymous = anonymous;
+    }
+    if (user.name !== null && user.name !== undefined) {
+        singleKindContext.name = user.name;
+    }
+    if (user.ip !== null && user.ip !== undefined) {
+        singleKindContext.ip = user.ip;
+    }
+    if (user.firstName !== null && user.firstName !== undefined) {
+        singleKindContext.firstName = user.firstName;
+    }
+    if (user.lastName !== null && user.lastName !== undefined) {
+        singleKindContext.lastName = user.lastName;
+    }
+    if (user.email !== null && user.email !== undefined) {
+        singleKindContext.email = user.email;
+    }
+    if (user.avatar !== null && user.avatar !== undefined) {
+        singleKindContext.avatar = user.avatar;
+    }
+    if (user.country !== null && user.country !== undefined) {
+        singleKindContext.country = user.country;
+    }
+    if (user.privateAttributeNames !== null && user.privateAttributeNames !== undefined) {
+        singleKindContext._meta = {
+            privateAttributes: user.privateAttributeNames,
+        };
+    }
+    // We are not pulling private attributes over because we will serialize
+    // those from attribute references for events.
+    return singleKindContext;
+}
+/**
+ * Container for a context/contexts. Because contexts come from external code
+ * they must be thoroughly validated and then formed to comply with
+ * the type system.
+ */
+class Context {
+    /**
+     * Contexts should be created using the static factory method {@link Context.fromLDContext}.
+     * @param kind The kind of the context.
+     *
+     * The factory methods are static functions within the class because they access private
+     * implementation details, so they cannot be free functions.
+     */
+    constructor(valid, kind, message) {
+        this._isMulti = false;
+        this._isUser = false;
+        this._wasLegacy = false;
+        this._contexts = {};
+        this.kind = kind;
+        this.valid = valid;
+        this.message = message;
+    }
+    static _contextForError(kind, message) {
+        return new Context(false, kind, message);
+    }
+    static _getValueFromContext(reference, context) {
+        if (!context || !reference.isValid) {
+            return undefined;
+        }
+        if (reference.depth === 1 && reference.getComponent(0) === 'anonymous') {
+            return !!context?.anonymous;
+        }
+        return reference.get(context);
+    }
+    _contextForKind(kind) {
+        if (this._isMulti) {
+            return this._contexts[kind];
+        }
+        if (this.kind === kind) {
+            return this._context;
+        }
+        return undefined;
+    }
+    static _fromMultiKindContext(context) {
+        const kinds = Object.keys(context).filter((key) => key !== 'kind');
+        const kindsValid = kinds.every(validKind);
+        if (!kinds.length) {
+            return Context._contextForError('multi', 'A multi-kind context must contain at least one kind');
+        }
+        if (!kindsValid) {
+            return Context._contextForError('multi', 'Context contains invalid kinds');
+        }
+        const privateAttributes = {};
+        let contextsAreObjects = true;
+        const contexts = kinds.reduce((acc, kind) => {
+            const singleContext = context[kind];
+            if (isContextCommon(singleContext)) {
+                acc[kind] = singleContext;
+                privateAttributes[kind] = processPrivateAttributes(singleContext._meta?.privateAttributes);
+            }
+            else {
+                // No early break isn't the most efficient, but it is an error condition.
+                contextsAreObjects = false;
+            }
+            return acc;
+        }, {});
+        if (!contextsAreObjects) {
+            return Context._contextForError('multi', 'Context contained contexts that were not objects');
+        }
+        if (!Object.values(contexts).every((part) => validKey(part.key))) {
+            return Context._contextForError('multi', 'Context contained invalid keys');
+        }
+        // There was only a single kind in the multi-kind context.
+        // So we can just translate this to a single-kind context.
+        if (kinds.length === 1) {
+            const kind = kinds[0];
+            const created = new Context(true, kind);
+            created._context = { ...contexts[kind], kind };
+            created._privateAttributeReferences = privateAttributes;
+            created._isUser = kind === 'user';
+            return created;
+        }
+        const created = new Context(true, context.kind);
+        created._contexts = contexts;
+        created._privateAttributeReferences = privateAttributes;
+        created._isMulti = true;
+        return created;
+    }
+    static _fromSingleKindContext(context) {
+        const { key, kind } = context;
+        const kindValid = validKind(kind);
+        const keyValid = validKey(key);
+        if (!kindValid) {
+            return Context._contextForError(kind ?? 'unknown', 'The kind was not valid for the context');
+        }
+        if (!keyValid) {
+            return Context._contextForError(kind, 'The key for the context was not valid');
+        }
+        // The JSON interfaces uses dangling _.
+        // eslint-disable-next-line no-underscore-dangle
+        const privateAttributeReferences = processPrivateAttributes(context._meta?.privateAttributes);
+        const created = new Context(true, kind);
+        created._isUser = kind === 'user';
+        created._context = context;
+        created._privateAttributeReferences = {
+            [kind]: privateAttributeReferences,
+        };
+        return created;
+    }
+    static _fromLegacyUser(context) {
+        const keyValid = context.key !== undefined && context.key !== null;
+        // For legacy users we allow empty keys.
+        if (!keyValid) {
+            return Context._contextForError('user', 'The key for the context was not valid');
+        }
+        const created = new Context(true, 'user');
+        created._isUser = true;
+        created._wasLegacy = true;
+        created._context = legacyToSingleKind(context);
+        created._privateAttributeReferences = {
+            user: processPrivateAttributes(context.privateAttributeNames, true),
+        };
+        return created;
+    }
+    /**
+     * Attempt to create a {@link Context} from an {@link LDContext}.
+     * @param context The input context to create a Context from.
+     * @returns a {@link Context}, if the context was not valid, then the returned contexts `valid`
+     * property will be false.
+     */
+    static fromLDContext(context) {
+        if (!context) {
+            return Context._contextForError('unknown', 'No context specified. Returning default value');
+        }
+        if (isSingleKind(context)) {
+            return Context._fromSingleKindContext(context);
+        }
+        if (isMultiKind(context)) {
+            return Context._fromMultiKindContext(context);
+        }
+        if (isLegacyUser(context)) {
+            return Context._fromLegacyUser(context);
+        }
+        return Context._contextForError('unknown', 'Context was not of a valid kind');
+    }
+    /**
+     * Creates a {@link LDContext} from a {@link Context}.
+     * @param context to be converted
+     * @returns an {@link LDContext} if input was valid, otherwise undefined
+     */
+    static toLDContext(context) {
+        if (!context.valid) {
+            return undefined;
+        }
+        const contexts = context.getContexts();
+        if (!context._isMulti) {
+            return contexts[0][1];
+        }
+        const result = {
+            kind: 'multi',
+        };
+        contexts.forEach((kindAndContext) => {
+            const kind = kindAndContext[0];
+            const nestedContext = kindAndContext[1];
+            result[kind] = nestedContext;
+        });
+        return result;
+    }
+    /**
+     * Attempt to get a value for the given context kind using the given reference.
+     * @param reference The reference to the value to get.
+     * @param kind The kind of the context to get the value for.
+     * @returns a value or `undefined` if one is not found.
+     */
+    valueForKind(reference, kind = DEFAULT_KIND) {
+        if (reference.isKind) {
+            return this.kinds;
+        }
+        return Context._getValueFromContext(reference, this._contextForKind(kind));
+    }
+    /**
+     * Attempt to get a key for the specified kind.
+     * @param kind The kind to get a key for.
+     * @returns The key for the specified kind, or undefined.
+     */
+    key(kind = DEFAULT_KIND) {
+        return this._contextForKind(kind)?.key;
+    }
+    /**
+     * True if this is a multi-kind context.
+     */
+    get isMultiKind() {
+        return this._isMulti;
+    }
+    /**
+     * Get the canonical key for this context.
+     */
+    get canonicalKey() {
+        if (this._isUser) {
+            return this._context.key;
+        }
+        if (this._isMulti) {
+            return Object.keys(this._contexts)
+                .sort()
+                .map((key) => `${key}:${encodeKey(this._contexts[key].key)}`)
+                .join(':');
+        }
+        return `${this.kind}:${encodeKey(this._context.key)}`;
+    }
+    /**
+     * Get the kinds of this context.
+     */
+    get kinds() {
+        if (this._isMulti) {
+            return Object.keys(this._contexts);
+        }
+        return [this.kind];
+    }
+    /**
+     * Get the kinds, and their keys, for this context.
+     */
+    get kindsAndKeys() {
+        if (this._isMulti) {
+            return Object.entries(this._contexts).reduce((acc, [kind, context]) => {
+                acc[kind] = context.key;
+                return acc;
+            }, {});
+        }
+        return { [this.kind]: this._context.key };
+    }
+    /**
+     * Get the attribute references.
+     *
+     * @param kind
+     */
+    privateAttributes(kind) {
+        return this._privateAttributeReferences?.[kind] || [];
+    }
+    /**
+     * Get the underlying context objects from this context.
+     *
+     * This method is intended to be used in event generation.
+     *
+     * The returned objects should not be modified.
+     */
+    getContexts() {
+        if (this._isMulti) {
+            return Object.entries(this._contexts);
+        }
+        return [[this.kind, this._context]];
+    }
+    get legacy() {
+        return this._wasLegacy;
+    }
+}
+Context.UserKind = DEFAULT_KIND;
+
+// _meta is part of the specification.
+// These attributes cannot be removed via a private attribute.
+const protectedAttributes = ['key', 'kind', '_meta', 'anonymous'].map((str) => new AttributeReference(str, true));
+// Attributes that should be stringified for legacy users.
+const legacyTopLevelCopyAttributes = [
+    'name',
+    'ip',
+    'firstName',
+    'lastName',
+    'email',
+    'avatar',
+    'country',
+];
+function compare(a, b) {
+    return a.depth === b.length && b.every((value, index) => value === a.getComponent(index));
+}
+function cloneWithRedactions(target, references) {
+    const stack = [];
+    const cloned = {};
+    const excluded = [];
+    stack.push(...Object.keys(target).map((key) => ({
+        key,
+        ptr: [key],
+        source: target,
+        parent: cloned,
+        visited: [target],
+    })));
+    while (stack.length) {
+        const item = stack.pop();
+        const redactRef = references.find((ref) => compare(ref, item.ptr));
+        if (!redactRef) {
+            const value = item.source[item.key];
+            // Handle null because it overlaps with object, which we will want to handle later.
+            if (value === null) {
+                item.parent[item.key] = value;
+            }
+            else if (Array.isArray(value)) {
+                item.parent[item.key] = [...value];
+            }
+            else if (typeof value === 'object') {
+                // Arrays and null must already be handled.
+                // Prevent cycles by not visiting the same object
+                // with in the same branch. Different branches
+                // may contain the same object.
+                //
+                // Same object visited twice in different branches.
+                // A -> B -> D
+                //   -> C -> D
+                // This is fine, which is why it doesn't just check if the object
+                // was visited ever.
+                if (!item.visited.includes(value)) {
+                    item.parent[item.key] = {};
+                    stack.push(...Object.keys(value).map((key) => ({
+                        key,
+                        ptr: [...item.ptr, key],
+                        source: value,
+                        parent: item.parent[item.key],
+                        visited: [...item.visited, value],
+                    })));
+                }
+            }
+            else {
+                item.parent[item.key] = value;
+            }
+        }
+        else {
+            excluded.push(redactRef.redactionName);
+        }
+    }
+    return { cloned, excluded: excluded.sort() };
+}
+class ContextFilter {
+    constructor(_allAttributesPrivate, _privateAttributes) {
+        this._allAttributesPrivate = _allAttributesPrivate;
+        this._privateAttributes = _privateAttributes;
+    }
+    filter(context, redactAnonymousAttributes = false) {
+        const contexts = context.getContexts();
+        if (contexts.length === 1) {
+            return this._filterSingleKind(context, contexts[0][1], contexts[0][0], redactAnonymousAttributes);
+        }
+        const filteredMulti = {
+            kind: 'multi',
+        };
+        contexts.forEach(([kind, single]) => {
+            filteredMulti[kind] = this._filterSingleKind(context, single, kind, redactAnonymousAttributes);
+        });
+        return filteredMulti;
+    }
+    _getAttributesToFilter(context, single, kind, redactAllAttributes) {
+        return (redactAllAttributes
+            ? Object.keys(single).map((k) => new AttributeReference(k, true))
+            : [...this._privateAttributes, ...context.privateAttributes(kind)]).filter((attr) => !protectedAttributes.some((protectedAttr) => protectedAttr.compare(attr)));
+    }
+    _filterSingleKind(context, single, kind, redactAnonymousAttributes) {
+        const redactAllAttributes = this._allAttributesPrivate || (redactAnonymousAttributes && single.anonymous === true);
+        const { cloned, excluded } = cloneWithRedactions(single, this._getAttributesToFilter(context, single, kind, redactAllAttributes));
+        if (context.legacy) {
+            legacyTopLevelCopyAttributes.forEach((name) => {
+                if (name in cloned) {
+                    cloned[name] = String(cloned[name]);
+                }
+            });
+        }
+        if (excluded.length) {
+            if (!cloned._meta) {
+                cloned._meta = {};
+            }
+            cloned._meta.redactedAttributes = excluded;
+        }
+        if (cloned._meta) {
+            delete cloned._meta.privateAttributes;
+            if (Object.keys(cloned._meta).length === 0) {
+                delete cloned._meta;
+            }
+        }
+        return cloned;
+    }
+}
+
+var DataSourceErrorKind;
+(function (DataSourceErrorKind) {
+    /// An unexpected error, such as an uncaught exception, further
+    /// described by the error message.
+    DataSourceErrorKind["Unknown"] = "UNKNOWN";
+    /// An I/O error such as a dropped connection.
+    DataSourceErrorKind["NetworkError"] = "NETWORK_ERROR";
+    /// The LaunchDarkly service returned an HTTP response with an error
+    /// status, available in the status code.
+    DataSourceErrorKind["ErrorResponse"] = "ERROR_RESPONSE";
+    /// The SDK received malformed data from the LaunchDarkly service.
+    DataSourceErrorKind["InvalidData"] = "INVALID_DATA";
+})(DataSourceErrorKind || (DataSourceErrorKind = {}));
+
+class LDFileDataSourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LaunchDarklyFileDataSourceError';
+    }
+}
+class LDPollingError extends Error {
+    constructor(kind, message, status, recoverable = true) {
+        super(message);
+        this.kind = kind;
+        this.status = status;
+        this.name = 'LaunchDarklyPollingError';
+        this.recoverable = recoverable;
+    }
+}
+class LDStreamingError extends Error {
+    constructor(kind, message, code, recoverable = true) {
+        super(message);
+        this.kind = kind;
+        this.code = code;
+        this.name = 'LaunchDarklyStreamingError';
+        this.recoverable = recoverable;
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * Enable / disable Auto environment attributes. When enabled, the SDK will automatically
+ * provide data about the mobile environment where the application is running. This data makes it simpler to target
+ * your mobile customers based on application name or version, or on device characteristics including manufacturer,
+ * model, operating system, locale, and so on. We recommend enabling this when you configure the SDK. To learn more,
+ * read [Automatic environment attributes](https://docs.launchdarkly.com/sdk/features/environment-attributes).
+ * for more documentation.
+ *
+ * The default is disabled.
+ */
+var AutoEnvAttributes;
+(function (AutoEnvAttributes) {
+    AutoEnvAttributes[AutoEnvAttributes["Disabled"] = 0] = "Disabled";
+    AutoEnvAttributes[AutoEnvAttributes["Enabled"] = 1] = "Enabled";
+})(AutoEnvAttributes || (AutoEnvAttributes = {}));
+
+var LDEventType;
+(function (LDEventType) {
+    LDEventType[LDEventType["AnalyticsEvents"] = 0] = "AnalyticsEvents";
+    LDEventType[LDEventType["DiagnosticEvent"] = 1] = "DiagnosticEvent";
+})(LDEventType || (LDEventType = {}));
+var LDDeliveryStatus;
+(function (LDDeliveryStatus) {
+    LDDeliveryStatus[LDDeliveryStatus["Succeeded"] = 0] = "Succeeded";
+    LDDeliveryStatus[LDDeliveryStatus["Failed"] = 1] = "Failed";
+    LDDeliveryStatus[LDDeliveryStatus["FailedAndMustShutDown"] = 2] = "FailedAndMustShutDown";
+})(LDDeliveryStatus || (LDDeliveryStatus = {}));
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get LDDeliveryStatus () { return LDDeliveryStatus; },
+    get LDEventType () { return LDEventType; }
+});
+
+/**
+ * Attempt to produce a string representation of a value.
+ * The format should be roughly comparable to `util.format`
+ * aside from object which will be JSON versus the `util.inspect`
+ * format.
+ * @param val
+ * @returns A string representation of the value if possible.
+ */
+function tryStringify(val) {
+    if (typeof val === 'string') {
+        return val;
+    }
+    if (val === undefined) {
+        return 'undefined';
+    }
+    if (val === null) {
+        return 'null';
+    }
+    if (Object.prototype.hasOwnProperty.call(val, 'toString')) {
+        try {
+            return val.toString();
+        }
+        catch {
+            /* Keep going */
+        }
+    }
+    if (typeof val === 'bigint') {
+        return `${val}n`;
+    }
+    try {
+        return JSON.stringify(val);
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.indexOf('circular') >= 0) {
+            return '[Circular]';
+        }
+        return '[Not Stringifiable]';
+    }
+}
+/**
+ * Attempt to produce a numeric representation.
+ * BigInts have an `n` suffix.
+ * @param val
+ * @returns The numeric representation or 'NaN' if not numeric.
+ */
+function toNumber(val) {
+    // Symbol has to be treated special because it will
+    // throw an exception if an attempt is made to convert it.
+    if (typeof val === 'symbol') {
+        return 'NaN';
+    }
+    if (typeof val === 'bigint') {
+        return `${val}n`;
+    }
+    return String(Number(val));
+}
+/**
+ * Attempt to produce an integer representation.
+ * BigInts have an `n` suffix.
+ * @param val
+ * @returns The integer representation or 'NaN' if not numeric.
+ */
+function toInt(val) {
+    if (typeof val === 'symbol') {
+        return 'NaN';
+    }
+    if (typeof val === 'bigint') {
+        return `${val}n`;
+    }
+    return String(parseInt(val, 10));
+}
+/**
+ * Attempt to produce a float representation.
+ * BigInts have an `n` suffix.
+ * @param val
+ * @returns The integer representation or 'NaN' if not numeric.
+ */
+function toFloat(val) {
+    if (typeof val === 'symbol') {
+        return 'NaN';
+    }
+    return String(parseFloat(val));
+}
+// Based on:
+// https://nodejs.org/api/util.html#utilformatformat-args
+// The result will not match node exactly, but it should get the
+// right information through.
+const escapes = {
+    s: (val) => tryStringify(val),
+    d: (val) => toNumber(val),
+    i: (val) => toInt(val),
+    f: (val) => toFloat(val),
+    j: (val) => tryStringify(val),
+    o: (val) => tryStringify(val),
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    O: (val) => tryStringify(val),
+    c: () => '',
+};
+/**
+ * A basic formatted for use where `util.format` is not available.
+ * This will not be as performant, but it will produce formatted
+ * messages.
+ *
+ * @internal
+ *
+ * @param args
+ * @returns Formatted string.
+ */
+function format(...args) {
+    const formatString = args.shift();
+    if (TypeValidators.String.is(formatString)) {
+        let out = '';
+        let i = 0;
+        while (i < formatString.length) {
+            const char = formatString.charAt(i);
+            if (char === '%') {
+                const nextIndex = i + 1;
+                if (nextIndex < formatString.length) {
+                    const nextChar = formatString.charAt(i + 1);
+                    if (nextChar in escapes && args.length) {
+                        const value = args.shift();
+                        // This rule is for math.
+                        // eslint-disable-next-line no-unsafe-optional-chaining
+                        out += escapes[nextChar]?.(value);
+                    }
+                    else if (nextChar === '%') {
+                        out += '%';
+                    }
+                    else {
+                        out += `%${nextChar}`;
+                    }
+                    i += 2;
+                }
+            }
+            else {
+                out += char;
+                i += 1;
+            }
+        }
+        // If there are any args left after we exhaust the format string
+        // then just stick those on the end.
+        if (args.length) {
+            if (out.length) {
+                out += ' ';
+            }
+            out += args.map(tryStringify).join(' ');
+        }
+        return out;
+    }
+    return args.map(tryStringify).join(' ');
+}
+
+const LogPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4,
+};
+const LevelNames = ['debug', 'info', 'warn', 'error', 'none'];
+/**
+ * A basic logger which handles filtering by level.
+ *
+ * With the default options it will write to `console.error`
+ * and it will use the formatting provided by `console.error`.
+ * If the destination is overwritten, then it will use an included
+ * formatter similar to `util.format`.
+ *
+ * If a formatter is available, then that should be overridden
+ * as well for performance.
+ */
+class BasicLogger {
+    /**
+     * This should only be used as a default fallback and not as a convenient
+     * solution. In most cases you should construct a new instance with the
+     * appropriate options for your specific needs.
+     */
+    static get() {
+        return new BasicLogger({});
+    }
+    constructor(options) {
+        this._logLevel = LogPriority[options.level ?? 'info'] ?? LogPriority.info;
+        this._name = options.name ?? 'LaunchDarkly';
+        // eslint-disable-next-line no-console
+        this._destination = options.destination;
+        this._formatter = options.formatter;
+    }
+    _tryFormat(...args) {
+        try {
+            if (this._formatter) {
+                // In case the provided formatter fails.
+                return this._formatter?.(...args);
+            }
+            return format(...args);
+        }
+        catch {
+            return format(...args);
+        }
+    }
+    _tryWrite(msg) {
+        try {
+            this._destination(msg);
+        }
+        catch {
+            // eslint-disable-next-line no-console
+            console.error(msg);
+        }
+    }
+    _log(level, args) {
+        if (level >= this._logLevel) {
+            const prefix = `${LevelNames[level]}: [${this._name}]`;
+            try {
+                if (this._destination) {
+                    this._tryWrite(`${prefix} ${this._tryFormat(...args)}`);
+                }
+                else {
+                    // `console.error` has its own formatter.
+                    // So we don't need to do anything.
+                    // eslint-disable-next-line no-console
+                    console.error(...args);
+                }
+            }
+            catch {
+                // If all else fails do not break.
+                // eslint-disable-next-line no-console
+                console.error(...args);
+            }
+        }
+    }
+    error(...args) {
+        this._log(LogPriority.error, args);
+    }
+    warn(...args) {
+        this._log(LogPriority.warn, args);
+    }
+    info(...args) {
+        this._log(LogPriority.info, args);
+    }
+    debug(...args) {
+        this._log(LogPriority.debug, args);
+    }
+}
+
+const loggerRequirements = {
+    error: TypeValidators.Function,
+    warn: TypeValidators.Function,
+    info: TypeValidators.Function,
+    debug: TypeValidators.Function,
+};
+/**
+ * The safeLogger logic exists because we allow the application to pass in a custom logger, but
+ * there is no guarantee that the logger works correctly and if it ever throws exceptions there
+ * could be serious consequences (e.g. an uncaught exception within an error event handler, due
+ * to the SDK trying to log the error, can terminate the application). An exception could result
+ * from faulty logic in the logger implementation, or it could be that this is not a logger at
+ * all but some other kind of object; the former is handled by a catch block that logs an error
+ * message to the SDK's default logger, and we can at least partly guard against the latter by
+ * checking for the presence of required methods at configuration time.
+ */
+class SafeLogger {
+    /**
+     * Construct a safe logger with the specified logger.
+     * @param logger The logger to use.
+     * @param fallback A fallback logger to use in case an issue is  encountered using
+     * the provided logger.
+     */
+    constructor(logger, fallback) {
+        Object.entries(loggerRequirements).forEach(([level, validator]) => {
+            if (!validator.is(logger[level])) {
+                throw new Error(`Provided logger instance must support logger.${level}(...) method`);
+                // Note that the SDK normally does not throw exceptions to the application, but that rule
+                // does not apply to LDClient.init() which will throw an exception if the parameters are so
+                // invalid that we cannot proceed with creating the client. An invalid logger meets those
+                // criteria since the SDK calls the logger during nearly all of its operations.
+            }
+        });
+        this._logger = logger;
+        this._fallback = fallback;
+    }
+    _log(level, args) {
+        try {
+            this._logger[level](...args);
+        }
+        catch {
+            // If all else fails do not break.
+            this._fallback[level](...args);
+        }
+    }
+    error(...args) {
+        this._log('error', args);
+    }
+    warn(...args) {
+        this._log('warn', args);
+    }
+    info(...args) {
+        this._log('info', args);
+    }
+    debug(...args) {
+        this._log('debug', args);
+    }
+}
+
+const createSafeLogger = (logger) => {
+    const basicLogger = new BasicLogger({
+        level: 'info',
+        // eslint-disable-next-line no-console
+        destination: console.error,
+        formatter: format,
+    });
+    return logger ? new SafeLogger(logger, basicLogger) : basicLogger;
+};
+
+/**
+ * Messages for issues which can be encountered from processing the configuration options.
+ */
+class OptionMessages {
+    static deprecated(oldName, newName) {
+        return `"${oldName}" is deprecated, please use "${newName}"`;
+    }
+    static optionBelowMinimum(name, value, min) {
+        return `Config option "${name}" had invalid value of ${value}, using minimum of ${min} instead`;
+    }
+    static unknownOption(name) {
+        return `Ignoring unknown config option "${name}"`;
+    }
+    static wrongOptionType(name, expectedType, actualType) {
+        return `Config option "${name}" should be of type ${expectedType}, got ${actualType}, using default value`;
+    }
+    static wrongOptionTypeBoolean(name, actualType) {
+        return `Config option "${name}" should be a boolean, got ${actualType}, converting to boolean`;
+    }
+    static invalidTagValue(name) {
+        return `Config option "${name}" must only contain letters, numbers, ., _ or -.`;
+    }
+    static tagValueTooLong(name) {
+        return `Value of "${name}" was longer than 64 characters and was discarded.`;
+    }
+    static partialEndpoint(name) {
+        return `You have set custom uris without specifying the ${name} URI; connections may not work properly`;
+    }
+}
+
+/**
+ * Expression to validate characters that are allowed in tag keys and values.
+ */
+const allowedTagCharacters = /^(\w|\.|-)+$/;
+const regexValidator = TypeValidators.stringMatchingRegex(allowedTagCharacters);
+const tagValidator = {
+    is: (u, name) => {
+        if (regexValidator.is(u)) {
+            if (u.length > 64) {
+                return { valid: false, message: OptionMessages.tagValueTooLong(name) };
+            }
+            return { valid: true };
+        }
+        return { valid: false, message: OptionMessages.invalidTagValue(name) };
+    },
+};
+/**
+ * Class for managing tags.
+ */
+class ApplicationTags {
+    constructor(options) {
+        const tags = {};
+        const application = options?.application;
+        const logger = options?.logger;
+        if (application) {
+            Object.entries(application).forEach(([key, value]) => {
+                if (value !== null && value !== undefined) {
+                    const { valid, message } = tagValidator.is(value, `application.${key}`);
+                    if (!valid) {
+                        logger?.warn(message);
+                    }
+                    else if (key === 'versionName') {
+                        tags[`application-version-name`] = [value];
+                    }
+                    else {
+                        tags[`application-${key}`] = [value];
+                    }
+                }
+            });
+        }
+        const tagKeys = Object.keys(tags);
+        if (tagKeys.length) {
+            this.value = tagKeys
+                .sort()
+                .flatMap((key) => tags[key].sort().map((value) => `${key}/${value}`))
+                .join(' ');
+        }
+    }
+}
+
+/**
+ * The client context provides basic configuration and platform support which are required
+ * when building SDK components.
+ */
+class ClientContext {
+    constructor(sdkKey, configuration, platform) {
+        this.platform = platform;
+        this.basicConfiguration = {
+            tags: configuration.tags,
+            logger: configuration.logger,
+            offline: configuration.offline,
+            serviceEndpoints: configuration.serviceEndpoints,
+            sdkKey,
+        };
+    }
+}
+
+function canonicalizeUri(uri) {
+    return uri.replace(/\/+$/, '');
+}
+function canonicalizePath(path) {
+    return path.replace(/^\/+/, '').replace(/\?$/, '');
+}
+/**
+ * Specifies the base service URIs used by SDK components.
+ */
+class ServiceEndpoints {
+    constructor(streaming, polling, events = ServiceEndpoints.DEFAULT_EVENTS, analyticsEventPath = '/bulk', diagnosticEventPath = '/diagnostic', includeAuthorizationHeader = true, payloadFilterKey) {
+        this.streaming = canonicalizeUri(streaming);
+        this.polling = canonicalizeUri(polling);
+        this.events = canonicalizeUri(events);
+        this.analyticsEventPath = analyticsEventPath;
+        this.diagnosticEventPath = diagnosticEventPath;
+        this.includeAuthorizationHeader = includeAuthorizationHeader;
+        this.payloadFilterKey = payloadFilterKey;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+ServiceEndpoints.DEFAULT_EVENTS = 'https://events.launchdarkly.com';
+function getWithParams(uri, parameters) {
+    if (parameters.length === 0) {
+        return uri;
+    }
+    const parts = parameters.map(({ key, value }) => `${key}=${value}`);
+    return `${uri}?${parts.join('&')}`;
+}
+/**
+ * Get the URI for the streaming endpoint.
+ *
+ * @param endpoints The service endpoints.
+ * @param path The path to the resource, devoid of any query parameters or hrefs.
+ * @param parameters The query parameters. These query parameters must already have the appropriate encoding applied. This function WILL NOT apply it for you.
+ */
+function getStreamingUri(endpoints, path, parameters) {
+    const canonicalizedPath = canonicalizePath(path);
+    const combinedParameters = [...parameters];
+    if (endpoints.payloadFilterKey) {
+        combinedParameters.push({ key: 'filter', value: endpoints.payloadFilterKey });
+    }
+    return getWithParams(`${endpoints.streaming}/${canonicalizedPath}`, combinedParameters);
+}
+/**
+ * Get the URI for the polling endpoint.
+ *
+ * @param endpoints The service endpoints.
+ * @param path The path to the resource, devoid of any query parameters or hrefs.
+ * @param parameters The query parameters. These query parameters must already have the appropriate encoding applied. This function WILL NOT apply it for you.
+ */
+function getPollingUri(endpoints, path, parameters) {
+    const canonicalizedPath = canonicalizePath(path);
+    const combinedParameters = [...parameters];
+    if (endpoints.payloadFilterKey) {
+        combinedParameters.push({ key: 'filter', value: endpoints.payloadFilterKey });
+    }
+    return getWithParams(`${endpoints.polling}/${canonicalizedPath}`, combinedParameters);
+}
+/**
+ * Get the URI for the events endpoint.
+ *
+ * @param endpoints The service endpoints.
+ * @param path The path to the resource, devoid of any query parameters or hrefs.
+ * @param parameters The query parameters. These query parameters must already have the appropriate encoding applied. This function WILL NOT apply it for you.
+ */
+function getEventsUri(endpoints, path, parameters) {
+    const canonicalizedPath = canonicalizePath(path);
+    return getWithParams(`${endpoints.events}/${canonicalizedPath}`, parameters);
+}
+
+// These classes are of trivial complexity. If they become
+// more complex, then they could be independent files.
+/* eslint-disable max-classes-per-file */
+class LDUnexpectedResponseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LaunchDarklyUnexpectedResponseError';
+    }
+}
+class LDClientError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LaunchDarklyClientError';
+    }
+}
+class LDTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LaunchDarklyTimeoutError';
+    }
+}
+/**
+ * Check if the HTTP error is recoverable. This will return false if a request
+ * made with any payload could not recover. If the reason for the failure
+ * is payload specific, for instance a payload that is too large, then
+ * it could recover with a different payload.
+ */
+function isHttpRecoverable(status) {
+    if (status >= 400 && status < 500) {
+        return status === 400 || status === 408 || status === 429;
+    }
+    return true;
+}
+/**
+ * Returns true if the status could recover for a different payload.
+ *
+ * When used with event processing this indicates that we should discard
+ * the payload, but that a subsequent payload may succeed. Therefore we should
+ * not stop event processing.
+ */
+function isHttpLocallyRecoverable(status) {
+    if (status === 413) {
+        return true;
+    }
+    return isHttpRecoverable(status);
+}
+
+/**
+ * Returns a promise which errors after t seconds.
+ *
+ * @param t Timeout in seconds.
+ * @param taskName Name of task being timed for logging and error reporting.
+ */
+function cancelableTimedPromise(t, taskName) {
+    let timeout;
+    let resolve;
+    const promise = new Promise((_res, reject) => {
+        resolve = _res;
+        timeout = setTimeout(() => {
+            const e = `${taskName} timed out after ${t} seconds.`;
+            reject(new LDTimeoutError(e));
+        }, t * 1000);
+    });
+    return {
+        promise,
+        cancel: () => {
+            resolve();
+            clearTimeout(timeout);
+        },
+    };
+}
+
+function clone(obj) {
+    if (obj === undefined || obj === null) {
+        return obj;
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
+
+// eslint-disable-next-line import/prefer-default-export
+function secondsToMillis(sec) {
+    return Math.trunc(sec * 1000);
+}
+
+/**
+ * Wait before calling the same function. Useful for expensive calls.
+ * Adapted from https://amitd.co/code/typescript/debounce.
+ *
+ * @return The debounced function.
+ *
+ * @example
+ *
+ * ```js
+ * const debouncedFunction = debounce(e => {
+ *   console.log(e);
+ * }, 5000);
+ *
+ * // Console logs 'Hello world again ' after 5 seconds
+ * debouncedFunction('Hello world');
+ * debouncedFunction('Hello world again');
+ * ```
+ * @param fn The function to be debounced.
+ * @param delayMs Defaults to 5 seconds.
+ */
+const debounce = (fn, delayMs = 5000) => {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            fn(...args);
+        }, delayMs);
+    };
+};
+
+const isEmptyObject = (obj) => JSON.stringify(obj) === '{}';
+
+/**
+ * Strips all falsy and empty {} from a given object. Returns a new object with only truthy values.
+ * Sourced from below but modified to include checks for empty object and ignoring keys.
+ * https://www.w3resource.com/javascript-exercises/javascript-array-exercise-47.php
+ *
+ * @param obj
+ * @param ignoreKeys
+ */
+const deepCompact = (obj, ignoreKeys) => {
+    if (!obj) {
+        return obj;
+    }
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (Boolean(value) && !isEmptyObject(value) && !ignoreKeys?.includes(key)) {
+            acc[key] = typeof value === 'object' ? deepCompact(value, ignoreKeys) : value;
+        }
+        return acc;
+    }, {});
+};
+
+/* eslint-disable */
+// Ripped from https://github.com/epoberezkin/fast-deep-fastDeepEqual
+// {{? it.es6 }}
+// var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
+// {{?}}
+function fastDeepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+        if (a.constructor !== b.constructor)
+            return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (!fastDeepEqual(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        // {{? it.es6 }}
+        if (a instanceof Map && b instanceof Map) {
+            if (a.size !== b.size)
+                return false;
+            for (i of a.entries())
+                if (!b.has(i[0]))
+                    return false;
+            for (i of a.entries())
+                if (!fastDeepEqual(i[1], b.get(i[0])))
+                    return false;
+            return true;
+        }
+        if (a instanceof Set && b instanceof Set) {
+            if (a.size !== b.size)
+                return false;
+            for (i of a.entries())
+                if (!b.has(i[0]))
+                    return false;
+            return true;
+        }
+        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+            // @ts-ignore
+            length = a.length;
+            // @ts-ignore
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;) {
+                // @ts-ignore
+                if (a[i] !== b[i])
+                    return false;
+            }
+            return true;
+        }
+        // {{?}}
+        if (a.constructor === RegExp)
+            return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+            return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+            return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+                return false;
+        for (i = length; i-- !== 0;) {
+            var key = keys[i];
+            // {{? it.react }}
+            // if (key === '_owner' && a.$$typeof) {
+            //   // React-specific: avoid traversing React elements' _owner.
+            //   //  _owner contains circular references
+            //   // and is not needed when comparing the actual elements (and not their owners)
+            //   continue;
+            // }
+            // {{?}}
+            if (!fastDeepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    // true if both NaN, false otherwise
+    return a !== a && b !== b;
+}
+
+function defaultHeaders(sdkKey, info, tags, includeAuthorizationHeader = true, userAgentHeaderName = 'user-agent') {
+    const { userAgentBase, version, wrapperName, wrapperVersion } = info.sdkData();
+    const headers = {
+        [userAgentHeaderName]: `${userAgentBase ?? 'NodeJSClient'}/${version}`,
+    };
+    // edge sdks sets this to false because they use the clientSideID
+    // and they don't need the authorization header
+    if (includeAuthorizationHeader) {
+        headers.authorization = sdkKey;
+    }
+    if (wrapperName) {
+        headers['x-launchdarkly-wrapper'] = wrapperVersion
+            ? `${wrapperName}/${wrapperVersion}`
+            : wrapperName;
+    }
+    if (tags?.value) {
+        headers['x-launchdarkly-tags'] = tags.value;
+    }
+    return headers;
+}
+function httpErrorMessage(err, context, retryMessage) {
+    let desc;
+    if (err.status) {
+        desc = `error ${err.status}${err.status === 401 ? ' (invalid SDK key)' : ''}`;
+    }
+    else {
+        desc = `I/O error (${err.message || 'unknown error'})`;
+    }
+    const action = retryMessage ?? 'giving up permanently';
+    return `Received ${desc} for ${context} - ${action}`;
+}
+function shouldRetry({ status }) {
+    return status ? isHttpRecoverable(status) : true;
+}
+/**
+ * In react-native use base64-js to polyfill btoa. This is safe
+ * because the react-native repo uses it too. Set the global.btoa to the encode
+ * function of base64-js.
+ * https://github.com/beatgammit/base64-js
+ * https://github.com/axios/axios/issues/2235#issuecomment-512204616
+ *
+ * Ripped from https://thewoods.blog/base64url/
+ */
+const base64UrlEncode = (s, encoding) => encoding.btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+var noop = () => { };
+
+const sleep = async (delayMillis = 1000) => new Promise((resolve) => {
+    setTimeout(resolve, delayMillis);
+});
+
+/**
+ * Returns a promise which errors after t seconds.
+ *
+ * @param t Timeout in seconds.
+ * @param taskName Name of task being timed for logging and error reporting.
+ */
+const timedPromise = (t, taskName) => new Promise((_res, reject) => {
+    setTimeout(() => {
+        const e = `${taskName} timed out after ${t} seconds.`;
+        reject(new LDTimeoutError(e));
+    }, t * 1000);
+});
+
+class DiagnosticsManager {
+    constructor(sdkKey, _platform, _diagnosticInitConfig) {
+        this._platform = _platform;
+        this._diagnosticInitConfig = _diagnosticInitConfig;
+        this._streamInits = [];
+        this._startTime = Date.now();
+        this._dataSinceDate = this._startTime;
+        this._id = {
+            diagnosticId: _platform.crypto.randomUUID(),
+            sdkKeySuffix: sdkKey.length > 6 ? sdkKey.substring(sdkKey.length - 6) : sdkKey,
+        };
+    }
+    /**
+     * Creates the initial event that is sent by the event processor when the SDK starts up. This will
+     * not be repeated during the lifetime of the SDK client.
+     */
+    createInitEvent() {
+        const sdkData = this._platform.info.sdkData();
+        const platformData = this._platform.info.platformData();
+        return {
+            kind: 'diagnostic-init',
+            id: this._id,
+            creationDate: this._startTime,
+            sdk: sdkData,
+            configuration: this._diagnosticInitConfig,
+            platform: {
+                name: platformData.name,
+                osArch: platformData.os?.arch,
+                osName: platformData.os?.name,
+                osVersion: platformData.os?.version,
+                ...(platformData.additional || {}),
+            },
+        };
+    }
+    /**
+     * Records a stream connection attempt (called by the stream processor).
+     *
+     * @param timestamp Time of the *beginning* of the connection attempt.
+     * @param failed True if the connection failed, or we got a read timeout before receiving a "put".
+     * @param durationMillis Elapsed time between starting timestamp and when we either gave up/lost
+     * the connection or received a successful "put".
+     */
+    recordStreamInit(timestamp, failed, durationMillis) {
+        const item = { timestamp, failed, durationMillis };
+        this._streamInits.push(item);
+    }
+    /**
+     * Creates a periodic event containing time-dependent stats, and resets the state of the manager
+     * with regard to those stats.
+     *
+     * Note: the reason droppedEvents, deduplicatedUsers, and eventsInLastBatch are passed into this
+     * function, instead of being properties of the DiagnosticsManager, is that the event processor is
+     * the one who's calling this function and is also the one who's tracking those stats.
+     */
+    createStatsEventAndReset(droppedEvents, deduplicatedUsers, eventsInLastBatch) {
+        const currentTime = Date.now();
+        const evt = {
+            kind: 'diagnostic',
+            id: this._id,
+            creationDate: currentTime,
+            dataSinceDate: this._dataSinceDate,
+            droppedEvents,
+            deduplicatedUsers,
+            eventsInLastBatch,
+            streamInits: this._streamInits,
+        };
+        this._streamInits = [];
+        this._dataSinceDate = currentTime;
+        return evt;
+    }
+}
+
+/**
+ * Different kinds of error which may be encountered during evaluation.
+ */
+var ErrorKinds;
+(function (ErrorKinds) {
+    ErrorKinds["MalformedFlag"] = "MALFORMED_FLAG";
+    ErrorKinds["UserNotSpecified"] = "USER_NOT_SPECIFIED";
+    ErrorKinds["FlagNotFound"] = "FLAG_NOT_FOUND";
+    ErrorKinds["ClientNotReady"] = "CLIENT_NOT_READY";
+    ErrorKinds["WrongType"] = "WRONG_TYPE";
+})(ErrorKinds || (ErrorKinds = {}));
+var ErrorKinds$1 = ErrorKinds;
+
+/**
+ * Messages for issues which can be encountered processing client requests.
+ */
+class ClientMessages {
+    static invalidMetricValue(badType) {
+        return ('The track function was called with a non-numeric "metricValue"' +
+            ` (${badType}), only numeric metric values are supported.`);
+    }
+}
+ClientMessages.MissingContextKeyNoEvent = 'Context was unspecified or had no key; event will not be sent';
+
+class EventSender {
+    constructor(clientContext, baseHeaders) {
+        const { basicConfiguration, platform } = clientContext;
+        const { serviceEndpoints: { analyticsEventPath, diagnosticEventPath }, } = basicConfiguration;
+        const { crypto, requests } = platform;
+        this._defaultHeaders = { ...baseHeaders };
+        this._eventsUri = getEventsUri(basicConfiguration.serviceEndpoints, analyticsEventPath, []);
+        this._diagnosticEventsUri = getEventsUri(basicConfiguration.serviceEndpoints, diagnosticEventPath, []);
+        this._requests = requests;
+        this._crypto = crypto;
+    }
+    async _tryPostingEvents(events, uri, payloadId, canRetry) {
+        const tryRes = {
+            status: LDDeliveryStatus.Succeeded,
+        };
+        const headers = {
+            ...this._defaultHeaders,
+            'content-type': 'application/json',
+        };
+        if (payloadId) {
+            headers['x-launchdarkly-payload-id'] = payloadId;
+            headers['x-launchDarkly-event-schema'] = '4';
+        }
+        let error;
+        try {
+            const { status, headers: resHeaders } = await this._requests.fetch(uri, {
+                headers,
+                body: JSON.stringify(events),
+                method: 'POST',
+                // When sending events from browser environments the request should be completed even
+                // if the user is navigating away from the page.
+                keepalive: true,
+            });
+            const serverDate = Date.parse(resHeaders.get('date') || '');
+            if (serverDate) {
+                tryRes.serverTime = serverDate;
+            }
+            if (status <= 204) {
+                return tryRes;
+            }
+            error = new LDUnexpectedResponseError(httpErrorMessage({ status, message: 'some events were dropped' }, 'event posting'));
+            if (!isHttpRecoverable(status)) {
+                // If the HTTP request isn't recoverable. Meaning if we made the same request it
+                // would not recover, then we check if a different request could recover.
+                // If a different request could not recover, then we shutdown. If a different request could
+                // recover, then we just don't retry this specific request.
+                if (!isHttpLocallyRecoverable(status)) {
+                    tryRes.status = LDDeliveryStatus.FailedAndMustShutDown;
+                }
+                else {
+                    tryRes.status = LDDeliveryStatus.Failed;
+                }
+                tryRes.error = error;
+                return tryRes;
+            }
+        }
+        catch (err) {
+            error = err;
+        }
+        // recoverable but not retrying
+        if (error && !canRetry) {
+            tryRes.status = LDDeliveryStatus.Failed;
+            tryRes.error = error;
+            return tryRes;
+        }
+        // wait 1 second before retrying
+        await sleep();
+        return this._tryPostingEvents(events, this._eventsUri, payloadId, false);
+    }
+    async sendEventData(type, data) {
+        const payloadId = type === LDEventType.AnalyticsEvents ? this._crypto.randomUUID() : undefined;
+        const uri = type === LDEventType.AnalyticsEvents ? this._eventsUri : this._diagnosticEventsUri;
+        return this._tryPostingEvents(data, uri, payloadId, true);
+    }
+}
+
+function isFeature(u) {
+    return u.kind === 'feature';
+}
+function isIdentify(u) {
+    return u.kind === 'identify';
+}
+function isMigration(u) {
+    return u.kind === 'migration_op';
+}
+
+/**
+ * @internal
+ */
+class SummaryCounter {
+    constructor(count, key, value, defValue, version, variation) {
+        this.count = count;
+        this.key = key;
+        this.value = value;
+        this.version = version;
+        this.variation = variation;
+        this.default = defValue;
+    }
+    increment() {
+        this.count += 1;
+    }
+}
+
+function counterKey(event) {
+    return `${event.key}:${event.variation !== null && event.variation !== undefined ? event.variation : ''}:${event.version !== null && event.version !== undefined ? event.version : ''}`;
+}
+/**
+ * @internal
+ */
+class EventSummarizer {
+    constructor() {
+        this._startDate = 0;
+        this._endDate = 0;
+        this._counters = {};
+        this._contextKinds = {};
+    }
+    summarizeEvent(event) {
+        if (isFeature(event) && !event.excludeFromSummaries) {
+            const countKey = counterKey(event);
+            const counter = this._counters[countKey];
+            let kinds = this._contextKinds[event.key];
+            if (!kinds) {
+                kinds = new Set();
+                this._contextKinds[event.key] = kinds;
+            }
+            event.context.kinds.forEach((kind) => kinds.add(kind));
+            if (counter) {
+                counter.increment();
+            }
+            else {
+                this._counters[countKey] = new SummaryCounter(1, event.key, event.value, event.default, event.version, event.variation);
+            }
+            if (this._startDate === 0 || event.creationDate < this._startDate) {
+                this._startDate = event.creationDate;
+            }
+            if (event.creationDate > this._endDate) {
+                this._endDate = event.creationDate;
+            }
+        }
+    }
+    getSummary() {
+        const features = Object.values(this._counters).reduce((acc, counter) => {
+            let flagSummary = acc[counter.key];
+            if (!flagSummary) {
+                flagSummary = {
+                    default: counter.default,
+                    counters: [],
+                    contextKinds: [...this._contextKinds[counter.key]],
+                };
+                acc[counter.key] = flagSummary;
+            }
+            const counterOut = {
+                value: counter.value,
+                count: counter.count,
+            };
+            if (counter.variation !== undefined && counter.variation !== null) {
+                counterOut.variation = counter.variation;
+            }
+            if (counter.version !== undefined && counter.version !== null) {
+                counterOut.version = counter.version;
+            }
+            else {
+                counterOut.unknown = true;
+            }
+            flagSummary.counters.push(counterOut);
+            return acc;
+        }, {});
+        return {
+            startDate: this._startDate,
+            endDate: this._endDate,
+            features,
+            kind: 'summary',
+        };
+    }
+    clearSummary() {
+        this._startDate = 0;
+        this._endDate = 0;
+        this._counters = {};
+        this._contextKinds = {};
+    }
+}
+
+class LDInvalidSDKKeyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LaunchDarklyInvalidSDKKeyError';
+    }
+}
+
+/**
+ * The contents of this file are for event sampling. They are not used for
+ * any purpose requiring cryptographic security.
+ * */
+function shouldSample(ratio) {
+    const truncated = Math.trunc(ratio);
+    // A radio of 1 means 1 in 1. So that will always sample. No need
+    // to draw a random number.
+    if (truncated === 1) {
+        return true;
+    }
+    if (truncated === 0) {
+        return false;
+    }
+    // Math.random() * truncated) would return 0, 1, ... (ratio - 1).
+    // Checking for any number in the range will have approximately a 1 in X
+    // chance. So we check for 0 as it is part of any range.
+    return Math.floor(Math.random() * truncated) === 0;
+}
+
+class EventProcessor {
+    constructor(_config, clientContext, baseHeaders, _contextDeduplicator, _diagnosticsManager, start = true) {
+        this._config = _config;
+        this._contextDeduplicator = _contextDeduplicator;
+        this._diagnosticsManager = _diagnosticsManager;
+        this._summarizer = new EventSummarizer();
+        this._queue = [];
+        this._lastKnownPastTime = 0;
+        this._droppedEvents = 0;
+        this._deduplicatedUsers = 0;
+        this._exceededCapacity = false;
+        this._eventsInLastBatch = 0;
+        this._shutdown = false;
+        this._flushUsersTimer = null;
+        this._capacity = _config.eventsCapacity;
+        this._logger = clientContext.basicConfiguration.logger;
+        this._eventSender = new EventSender(clientContext, baseHeaders);
+        this._contextFilter = new ContextFilter(_config.allAttributesPrivate, _config.privateAttributes.map((ref) => new AttributeReference(ref)));
+        if (start) {
+            this.start();
+        }
+    }
+    start() {
+        if (this._contextDeduplicator?.flushInterval !== undefined) {
+            this._flushUsersTimer = setInterval(() => {
+                this._contextDeduplicator?.flush();
+            }, this._contextDeduplicator.flushInterval * 1000);
+        }
+        this._flushTimer = setInterval(async () => {
+            try {
+                await this.flush();
+            }
+            catch (e) {
+                // Log errors and swallow them
+                this._logger?.debug(`Flush failed: ${e}`);
+            }
+        }, this._config.flushInterval * 1000);
+        if (this._diagnosticsManager) {
+            const initEvent = this._diagnosticsManager.createInitEvent();
+            this._postDiagnosticEvent(initEvent);
+            this._diagnosticsTimer = setInterval(() => {
+                const statsEvent = this._diagnosticsManager.createStatsEventAndReset(this._droppedEvents, this._deduplicatedUsers, this._eventsInLastBatch);
+                this._droppedEvents = 0;
+                this._deduplicatedUsers = 0;
+                this._postDiagnosticEvent(statsEvent);
+            }, this._config.diagnosticRecordingInterval * 1000);
+        }
+        this._logger?.debug('Started EventProcessor.');
+    }
+    _postDiagnosticEvent(event) {
+        this._eventSender.sendEventData(LDEventType.DiagnosticEvent, event);
+    }
+    close() {
+        clearInterval(this._flushTimer);
+        if (this._flushUsersTimer) {
+            clearInterval(this._flushUsersTimer);
+        }
+        if (this._diagnosticsTimer) {
+            clearInterval(this._diagnosticsTimer);
+        }
+    }
+    async flush() {
+        if (this._shutdown) {
+            throw new LDInvalidSDKKeyError('Events cannot be posted because a permanent error has been encountered. ' +
+                'This is most likely an invalid SDK key. The specific error information ' +
+                'is logged independently.');
+        }
+        const eventsToFlush = this._queue;
+        this._queue = [];
+        const summary = this._summarizer.getSummary();
+        this._summarizer.clearSummary();
+        if (Object.keys(summary.features).length) {
+            eventsToFlush.push(summary);
+        }
+        if (!eventsToFlush.length) {
+            return;
+        }
+        this._eventsInLastBatch = eventsToFlush.length;
+        this._logger?.debug('Flushing %d events', eventsToFlush.length);
+        await this._tryPostingEvents(eventsToFlush);
+    }
+    sendEvent(inputEvent) {
+        if (this._shutdown) {
+            return;
+        }
+        if (isMigration(inputEvent)) {
+            // These conditions are not combined, because we always want to stop
+            // processing at this point for a migration event. It cannot generate
+            // an index event or debug event.
+            if (shouldSample(inputEvent.samplingRatio)) {
+                const migrationEvent = {
+                    ...inputEvent,
+                };
+                if (migrationEvent.samplingRatio === 1) {
+                    delete migrationEvent.samplingRatio;
+                }
+                this._enqueue(migrationEvent);
+            }
+            return;
+        }
+        this._summarizer.summarizeEvent(inputEvent);
+        const isFeatureEvent = isFeature(inputEvent);
+        const addFullEvent = (isFeatureEvent && inputEvent.trackEvents) || !isFeatureEvent;
+        const addDebugEvent = this._shouldDebugEvent(inputEvent);
+        const isIdentifyEvent = isIdentify(inputEvent);
+        const shouldNotDeduplicate = this._contextDeduplicator?.processContext(inputEvent.context);
+        // If there is no cache, then it will never be in the cache.
+        if (!shouldNotDeduplicate) {
+            if (!isIdentifyEvent) {
+                this._deduplicatedUsers += 1;
+            }
+        }
+        const addIndexEvent = shouldNotDeduplicate && !isIdentifyEvent;
+        if (addIndexEvent) {
+            this._enqueue(this._makeOutputEvent({
+                kind: 'index',
+                creationDate: inputEvent.creationDate,
+                context: inputEvent.context,
+                samplingRatio: 1,
+            }, false));
+        }
+        if (addFullEvent && shouldSample(inputEvent.samplingRatio)) {
+            this._enqueue(this._makeOutputEvent(inputEvent, false));
+        }
+        if (addDebugEvent && shouldSample(inputEvent.samplingRatio)) {
+            this._enqueue(this._makeOutputEvent(inputEvent, true));
+        }
+    }
+    _makeOutputEvent(event, debug) {
+        switch (event.kind) {
+            case 'feature': {
+                const out = {
+                    kind: debug ? 'debug' : 'feature',
+                    creationDate: event.creationDate,
+                    context: this._contextFilter.filter(event.context, !debug),
+                    key: event.key,
+                    value: event.value,
+                    default: event.default,
+                };
+                if (event.samplingRatio !== 1) {
+                    out.samplingRatio = event.samplingRatio;
+                }
+                if (event.prereqOf) {
+                    out.prereqOf = event.prereqOf;
+                }
+                if (event.variation !== undefined) {
+                    out.variation = event.variation;
+                }
+                if (event.version !== undefined) {
+                    out.version = event.version;
+                }
+                if (event.reason) {
+                    out.reason = event.reason;
+                }
+                return out;
+            }
+            case 'index': // Intentional fallthrough.
+            case 'identify': {
+                const out = {
+                    kind: event.kind,
+                    creationDate: event.creationDate,
+                    context: this._contextFilter.filter(event.context),
+                };
+                if (event.samplingRatio !== 1) {
+                    out.samplingRatio = event.samplingRatio;
+                }
+                return out;
+            }
+            case 'custom': {
+                const out = {
+                    kind: 'custom',
+                    creationDate: event.creationDate,
+                    key: event.key,
+                    contextKeys: event.context.kindsAndKeys,
+                };
+                if (event.samplingRatio !== 1) {
+                    out.samplingRatio = event.samplingRatio;
+                }
+                if (event.data !== undefined) {
+                    out.data = event.data;
+                }
+                if (event.metricValue !== undefined) {
+                    out.metricValue = event.metricValue;
+                }
+                if (event.url !== undefined) {
+                    out.url = event.url;
+                }
+                return out;
+            }
+            case 'click': {
+                const out = {
+                    kind: 'click',
+                    creationDate: event.creationDate,
+                    contextKeys: event.context.kindsAndKeys,
+                    key: event.key,
+                    url: event.url,
+                    selector: event.selector,
+                };
+                return out;
+            }
+            case 'pageview': {
+                const out = {
+                    kind: 'pageview',
+                    creationDate: event.creationDate,
+                    contextKeys: event.context.kindsAndKeys,
+                    key: event.key,
+                    url: event.url,
+                };
+                return out;
+            }
+            default:
+                // This would happen during the addition of a new event type to the SDK.
+                return event;
+        }
+    }
+    _enqueue(event) {
+        if (this._queue.length < this._capacity) {
+            this._queue.push(event);
+            this._exceededCapacity = false;
+        }
+        else {
+            if (!this._exceededCapacity) {
+                this._exceededCapacity = true;
+                this._logger?.warn('Exceeded event queue capacity. Increase capacity to avoid dropping events.');
+            }
+            this._droppedEvents += 1;
+        }
+    }
+    _shouldDebugEvent(event) {
+        return (isFeature(event) &&
+            event.debugEventsUntilDate &&
+            event.debugEventsUntilDate > this._lastKnownPastTime &&
+            event.debugEventsUntilDate > Date.now());
+    }
+    async _tryPostingEvents(events) {
+        const res = await this._eventSender.sendEventData(LDEventType.AnalyticsEvents, events);
+        if (res.status === LDDeliveryStatus.FailedAndMustShutDown) {
+            this._shutdown = true;
+        }
+        if (res.serverTime) {
+            this._lastKnownPastTime = res.serverTime;
+        }
+        if (res.error) {
+            throw res.error;
+        }
+    }
+}
+
+class InputCustomEvent {
+    constructor(context, key, data, metricValue, 
+    // Currently custom events are not sampled, but this is here to make the handling
+    // code more uniform.
+    samplingRatio = 1, 
+    // Browser SDKs can include a URL for custom events.
+    url) {
+        this.context = context;
+        this.key = key;
+        this.data = data;
+        this.metricValue = metricValue;
+        this.samplingRatio = samplingRatio;
+        this.url = url;
+        this.kind = 'custom';
+        this.creationDate = Date.now();
+        this.context = context;
+    }
+}
+
+class InputEvalEvent {
+    constructor(withReasons, context, key, value, defValue, // default is a reserved keyword in this context.
+    version, variation, trackEvents, prereqOf, reason, debugEventsUntilDate, excludeFromSummaries, samplingRatio = 1) {
+        this.withReasons = withReasons;
+        this.context = context;
+        this.key = key;
+        this.samplingRatio = samplingRatio;
+        this.kind = 'feature';
+        this.creationDate = Date.now();
+        this.value = value;
+        this.default = defValue;
+        if (version !== undefined) {
+            this.version = version;
+        }
+        if (variation !== undefined) {
+            this.variation = variation;
+        }
+        if (trackEvents !== undefined) {
+            this.trackEvents = trackEvents;
+        }
+        if (prereqOf !== undefined) {
+            this.prereqOf = prereqOf;
+        }
+        if (reason !== undefined) {
+            this.reason = reason;
+        }
+        if (debugEventsUntilDate !== undefined) {
+            this.debugEventsUntilDate = debugEventsUntilDate;
+        }
+        if (excludeFromSummaries !== undefined) {
+            this.excludeFromSummaries = excludeFromSummaries;
+        }
+    }
+}
+
+class InputIdentifyEvent {
+    constructor(context, samplingRatio = 1) {
+        this.context = context;
+        this.samplingRatio = samplingRatio;
+        this.kind = 'identify';
+        this.creationDate = Date.now();
+    }
+}
+
+class NullEventProcessor {
+    close() { }
+    async flush() {
+        // empty comment to keep ts and eslint happy
+    }
+    sendEvent() { }
+}
+
+class EventFactoryBase {
+    constructor(_withReasons) {
+        this._withReasons = _withReasons;
+    }
+    evalEvent(e) {
+        return new InputEvalEvent(this._withReasons, e.context, e.flagKey, e.value, e.defaultVal, e.version, 
+        // Exclude null as a possibility.
+        e.variation ?? undefined, e.trackEvents || e.addExperimentData, e.prereqOfFlagKey, this._withReasons || e.addExperimentData ? e.reason : undefined, e.debugEventsUntilDate, e.excludeFromSummaries, e.samplingRatio);
+    }
+    unknownFlagEvent(key, defVal, context) {
+        return new InputEvalEvent(this._withReasons, context, key, defVal, defVal, 
+        // This isn't ideal, but the purpose of the factory is to at least
+        // handle this situation.
+        undefined, // version
+        undefined, // variation index
+        undefined, // track events
+        undefined, // prereqOf
+        undefined, // reason
+        undefined, // debugEventsUntilDate
+        undefined, // exclude from summaries
+        undefined);
+    }
+    /* eslint-disable-next-line class-methods-use-this */
+    identifyEvent(context) {
+        // Currently sampling for identify events is always 1.
+        return new InputIdentifyEvent(context, 1);
+    }
+    /* eslint-disable-next-line class-methods-use-this */
+    customEvent(key, context, data, metricValue, samplingRatio = 1) {
+        return new InputCustomEvent(context, key, data ?? undefined, metricValue ?? undefined, samplingRatio);
+    }
+}
+
+const reportJsonError = (type, data, logger, errorHandler) => {
+    logger?.error(`Stream received invalid data in "${type}" message`);
+    logger?.debug(`Invalid JSON follows: ${data}`);
+    errorHandler?.(new LDStreamingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in event stream'));
+};
+// TODO: SDK-156 - Move to Server SDK specific location
+class StreamingProcessor {
+    constructor(clientContext, streamUriPath, parameters, _listeners, baseHeaders, _diagnosticsManager, _errorHandler, _streamInitialReconnectDelay = 1) {
+        this._listeners = _listeners;
+        this._diagnosticsManager = _diagnosticsManager;
+        this._errorHandler = _errorHandler;
+        this._streamInitialReconnectDelay = _streamInitialReconnectDelay;
+        const { basicConfiguration, platform } = clientContext;
+        const { logger } = basicConfiguration;
+        const { requests } = platform;
+        this._headers = { ...baseHeaders };
+        this._logger = logger;
+        this._requests = requests;
+        this._streamUri = getStreamingUri(basicConfiguration.serviceEndpoints, streamUriPath, parameters);
+    }
+    _logConnectionStarted() {
+        this._connectionAttemptStartTime = Date.now();
+    }
+    _logConnectionResult(success) {
+        if (this._connectionAttemptStartTime && this._diagnosticsManager) {
+            this._diagnosticsManager.recordStreamInit(this._connectionAttemptStartTime, !success, Date.now() - this._connectionAttemptStartTime);
+        }
+        this._connectionAttemptStartTime = undefined;
+    }
+    /**
+     * This is a wrapper around the passed errorHandler which adds additional
+     * diagnostics and logging logic.
+     *
+     * @param err The error to be logged and handled.
+     * @return boolean whether to retry the connection.
+     *
+     * @private
+     */
+    _retryAndHandleError(err) {
+        if (!shouldRetry(err)) {
+            this._logConnectionResult(false);
+            this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status));
+            this._logger?.error(httpErrorMessage(err, 'streaming request'));
+            return false;
+        }
+        this._logger?.warn(httpErrorMessage(err, 'streaming request', 'will retry'));
+        this._logConnectionResult(false);
+        this._logConnectionStarted();
+        return true;
+    }
+    start() {
+        this._logConnectionStarted();
+        // TLS is handled by the platform implementation.
+        const eventSource = this._requests.createEventSource(this._streamUri, {
+            headers: this._headers,
+            errorFilter: (error) => this._retryAndHandleError(error),
+            initialRetryDelayMillis: 1000 * this._streamInitialReconnectDelay,
+            readTimeoutMillis: 5 * 60 * 1000,
+            retryResetIntervalMillis: 60 * 1000,
+        });
+        this._eventSource = eventSource;
+        eventSource.onclose = () => {
+            this._logger?.info('Closed LaunchDarkly stream connection');
+        };
+        eventSource.onerror = () => {
+            // The work is done by `errorFilter`.
+        };
+        eventSource.onopen = () => {
+            this._logger?.info('Opened LaunchDarkly stream connection');
+        };
+        eventSource.onretrying = (e) => {
+            this._logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
+        };
+        this._listeners.forEach(({ deserializeData, processJson }, eventName) => {
+            eventSource.addEventListener(eventName, (event) => {
+                this._logger?.debug(`Received ${eventName} event`);
+                if (event?.data) {
+                    this._logConnectionResult(true);
+                    const { data } = event;
+                    const dataJson = deserializeData(data);
+                    if (!dataJson) {
+                        reportJsonError(eventName, data, this._logger, this._errorHandler);
+                        return;
+                    }
+                    processJson(dataJson);
+                }
+                else {
+                    this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.Unknown, 'Unexpected payload from event stream'));
+                }
+            });
+        });
+    }
+    stop() {
+        this._eventSource?.close();
+        this._eventSource = undefined;
+    }
+    close() {
+        this.stop();
+    }
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ClientMessages: ClientMessages,
+    DiagnosticsManager: DiagnosticsManager,
+    ErrorKinds: ErrorKinds$1,
+    EventFactoryBase: EventFactoryBase,
+    EventProcessor: EventProcessor,
+    InputCustomEvent: InputCustomEvent,
+    InputEvalEvent: InputEvalEvent,
+    InputIdentifyEvent: InputIdentifyEvent,
+    NullEventProcessor: NullEventProcessor,
+    StreamingProcessor: StreamingProcessor,
+    isLegacyUser: isLegacyUser,
+    isMultiKind: isMultiKind,
+    isSingleKind: isSingleKind,
+    shouldSample: shouldSample
+});
+
+export { ApplicationTags, AttributeReference, AutoEnvAttributes, BasicLogger, ClientContext, Context, ContextFilter, DataSourceErrorKind, DateValidator, FactoryOrInstance, Function, KindValidator, LDClientError, LDFileDataSourceError, LDPollingError, LDStreamingError, LDTimeoutError, LDUnexpectedResponseError, NullableBoolean, NumberWithMinimum, OptionMessages, SafeLogger, ServiceEndpoints, StringMatchingRegex, Type, TypeArray, TypeValidators, base64UrlEncode, cancelableTimedPromise, clone, createSafeLogger, debounce, deepCompact, defaultHeaders, fastDeepEqual, getEventsUri, getPollingUri, getStreamingUri, httpErrorMessage, index as internal, isHttpLocallyRecoverable, isHttpRecoverable, noop, secondsToMillis, shouldRetry, sleep, index$1 as subsystem, timedPromise };
+//# sourceMappingURL=index.mjs.map