{"version":3,"file":"./js/growthbook.min.js","mappings":"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","sources":["webpack:///../../../../../node_modules/dom-mutator/dist/dom-mutator.esm.js","webpack:///../../../../../node_modules/@growthbook/growthbook/dist/esm/util.mjs","webpack:///../../../../../node_modules/@growthbook/growthbook/dist/esm/mongrule.mjs","webpack:///../../../../../node_modules/@growthbook/growthbook/dist/esm/feature-repository.mjs","webpack:///../../../../../node_modules/@growthbook/growthbook/dist/esm/GrowthBook.mjs","webpack:///../growthbook.ts"],"sourcesContent":["var validAttributeName = /^[a-zA-Z:_][a-zA-Z0-9:_.-]*$/;\nvar nullController = {\n  revert: function revert() {}\n};\nvar elements = /*#__PURE__*/new Map();\nvar mutations = /*#__PURE__*/new Set();\n\nfunction getObserverInit(attr) {\n  return attr === 'html' ? {\n    childList: true,\n    subtree: true,\n    attributes: true,\n    characterData: true\n  } : {\n    childList: false,\n    subtree: false,\n    attributes: true,\n    attributeFilter: [attr]\n  };\n}\n\nfunction getElementRecord(element) {\n  var record = elements.get(element);\n\n  if (!record) {\n    record = {\n      element: element,\n      attributes: {}\n    };\n    elements.set(element, record);\n  }\n\n  return record;\n}\n\nfunction createElementPropertyRecord(el, attr, getCurrentValue, setValue, mutationRunner) {\n  var currentValue = getCurrentValue(el);\n  var record = {\n    isDirty: false,\n    originalValue: currentValue,\n    virtualValue: currentValue,\n    mutations: [],\n    el: el,\n    _positionTimeout: null,\n    observer: new MutationObserver(function () {\n      // enact a 1 second timeout that blocks subsequent firing of the\n      // observer until the timeout is complete. This will prevent multiple\n      // mutations from firing in quick succession, which can cause the\n      // mutation to be reverted before the DOM has a chance to update.\n      if (attr === 'position' && record._positionTimeout) return;else if (attr === 'position') record._positionTimeout = setTimeout(function () {\n        record._positionTimeout = null;\n      }, 1000);\n      var currentValue = getCurrentValue(el);\n      if (attr === 'position' && currentValue.parentNode === record.virtualValue.parentNode && currentValue.insertBeforeNode === record.virtualValue.insertBeforeNode) return;\n      if (currentValue === record.virtualValue) return;\n      record.originalValue = currentValue;\n      mutationRunner(record);\n    }),\n    mutationRunner: mutationRunner,\n    setValue: setValue,\n    getCurrentValue: getCurrentValue\n  };\n\n  if (attr === 'position' && el.parentNode) {\n    record.observer.observe(el.parentNode, {\n      childList: true,\n      subtree: true,\n      attributes: false,\n      characterData: false\n    });\n  } else {\n    record.observer.observe(el, getObserverInit(attr));\n  }\n\n  return record;\n}\n\nfunction queueIfNeeded(val, record) {\n  var currentVal = record.getCurrentValue(record.el);\n  record.virtualValue = val;\n\n  if (val && typeof val !== 'string') {\n    if (!currentVal || val.parentNode !== currentVal.parentNode || val.insertBeforeNode !== currentVal.insertBeforeNode) {\n      record.isDirty = true;\n      runDOMUpdates();\n    }\n  } else if (val !== currentVal) {\n    record.isDirty = true;\n    runDOMUpdates();\n  }\n}\n\nfunction htmlMutationRunner(record) {\n  var val = record.originalValue;\n  record.mutations.forEach(function (m) {\n    return val = m.mutate(val);\n  });\n  queueIfNeeded(getTransformedHTML(val), record);\n}\n\nfunction classMutationRunner(record) {\n  var val = new Set(record.originalValue.split(/\\s+/).filter(Boolean));\n  record.mutations.forEach(function (m) {\n    return m.mutate(val);\n  });\n  queueIfNeeded(Array.from(val).filter(Boolean).join(' '), record);\n}\n\nfunction attrMutationRunner(record) {\n  var val = record.originalValue;\n  record.mutations.forEach(function (m) {\n    return val = m.mutate(val);\n  });\n  queueIfNeeded(val, record);\n}\n\nfunction _loadDOMNodes(_ref) {\n  var parentSelector = _ref.parentSelector,\n      insertBeforeSelector = _ref.insertBeforeSelector;\n  var parentNode = document.querySelector(parentSelector);\n  if (!parentNode) return null;\n  var insertBeforeNode = insertBeforeSelector ? document.querySelector(insertBeforeSelector) : null;\n  if (insertBeforeSelector && !insertBeforeNode) return null;\n  return {\n    parentNode: parentNode,\n    insertBeforeNode: insertBeforeNode\n  };\n}\n\nfunction positionMutationRunner(record) {\n  var val = record.originalValue;\n  record.mutations.forEach(function (m) {\n    var selectors = m.mutate();\n\n    var newNodes = _loadDOMNodes(selectors);\n\n    val = newNodes || val;\n  });\n  queueIfNeeded(val, record);\n}\n\nvar getHTMLValue = function getHTMLValue(el) {\n  return el.innerHTML;\n};\n\nvar setHTMLValue = function setHTMLValue(el, value) {\n  return el.innerHTML = value;\n};\n\nfunction getElementHTMLRecord(element) {\n  var elementRecord = getElementRecord(element);\n\n  if (!elementRecord.html) {\n    elementRecord.html = createElementPropertyRecord(element, 'html', getHTMLValue, setHTMLValue, htmlMutationRunner);\n  }\n\n  return elementRecord.html;\n}\n\nvar getElementPosition = function getElementPosition(el) {\n  return {\n    parentNode: el.parentElement,\n    insertBeforeNode: el.nextElementSibling\n  };\n};\n\nvar setElementPosition = function setElementPosition(el, value) {\n  if (value.insertBeforeNode && !value.parentNode.contains(value.insertBeforeNode)) {\n    // skip position mutation - insertBeforeNode not a child of parent. happens\n    // when mutation observer for indvidual element fires out of order\n    return;\n  }\n\n  value.parentNode.insertBefore(el, value.insertBeforeNode);\n};\n\nfunction getElementPositionRecord(element) {\n  var elementRecord = getElementRecord(element);\n\n  if (!elementRecord.position) {\n    elementRecord.position = createElementPropertyRecord(element, 'position', getElementPosition, setElementPosition, positionMutationRunner);\n  }\n\n  return elementRecord.position;\n}\n\nvar setClassValue = function setClassValue(el, val) {\n  return val ? el.className = val : el.removeAttribute('class');\n};\n\nvar getClassValue = function getClassValue(el) {\n  return el.className;\n};\n\nfunction getElementClassRecord(el) {\n  var elementRecord = getElementRecord(el);\n\n  if (!elementRecord.classes) {\n    elementRecord.classes = createElementPropertyRecord(el, 'class', getClassValue, setClassValue, classMutationRunner);\n  }\n\n  return elementRecord.classes;\n}\n\nvar getAttrValue = function getAttrValue(attrName) {\n  return function (el) {\n    var _el$getAttribute;\n\n    return (_el$getAttribute = el.getAttribute(attrName)) != null ? _el$getAttribute : null;\n  };\n};\n\nvar setAttrValue = function setAttrValue(attrName) {\n  return function (el, val) {\n    return val !== null ? el.setAttribute(attrName, val) : el.removeAttribute(attrName);\n  };\n};\n\nfunction getElementAttributeRecord(el, attr) {\n  var elementRecord = getElementRecord(el);\n\n  if (!elementRecord.attributes[attr]) {\n    elementRecord.attributes[attr] = createElementPropertyRecord(el, attr, getAttrValue(attr), setAttrValue(attr), attrMutationRunner);\n  }\n\n  return elementRecord.attributes[attr];\n}\n\nfunction deleteElementPropertyRecord(el, attr) {\n  var element = elements.get(el);\n  if (!element) return;\n\n  if (attr === 'html') {\n    var _element$html, _element$html$observe;\n\n    (_element$html = element.html) == null ? void 0 : (_element$html$observe = _element$html.observer) == null ? void 0 : _element$html$observe.disconnect();\n    delete element.html;\n  } else if (attr === 'class') {\n    var _element$classes, _element$classes$obse;\n\n    (_element$classes = element.classes) == null ? void 0 : (_element$classes$obse = _element$classes.observer) == null ? void 0 : _element$classes$obse.disconnect();\n    delete element.classes;\n  } else if (attr === 'position') {\n    var _element$position, _element$position$obs;\n\n    (_element$position = element.position) == null ? void 0 : (_element$position$obs = _element$position.observer) == null ? void 0 : _element$position$obs.disconnect();\n    delete element.position;\n  } else {\n    var _element$attributes, _element$attributes$a, _element$attributes$a2;\n\n    (_element$attributes = element.attributes) == null ? void 0 : (_element$attributes$a = _element$attributes[attr]) == null ? void 0 : (_element$attributes$a2 = _element$attributes$a.observer) == null ? void 0 : _element$attributes$a2.disconnect();\n    delete element.attributes[attr];\n  }\n}\n\nvar transformContainer;\n\nfunction getTransformedHTML(html) {\n  if (!transformContainer) {\n    transformContainer = document.createElement('div');\n  }\n\n  transformContainer.innerHTML = html;\n  return transformContainer.innerHTML;\n}\n\nfunction setPropertyValue(el, attr, m) {\n  if (!m.isDirty) return;\n  m.isDirty = false;\n  var val = m.virtualValue;\n\n  if (!m.mutations.length) {\n    deleteElementPropertyRecord(el, attr);\n  }\n\n  m.setValue(el, val);\n}\n\nfunction setValue(m, el) {\n  m.html && setPropertyValue(el, 'html', m.html);\n  m.classes && setPropertyValue(el, 'class', m.classes);\n  m.position && setPropertyValue(el, 'position', m.position);\n  Object.keys(m.attributes).forEach(function (attr) {\n    setPropertyValue(el, attr, m.attributes[attr]);\n  });\n}\n\nfunction runDOMUpdates() {\n  elements.forEach(setValue);\n} // find or create ElementPropertyRecord, add mutation to it, then run\n\n\nfunction startMutating(mutation, element) {\n  var record = null;\n\n  if (mutation.kind === 'html') {\n    record = getElementHTMLRecord(element);\n  } else if (mutation.kind === 'class') {\n    record = getElementClassRecord(element);\n  } else if (mutation.kind === 'attribute') {\n    record = getElementAttributeRecord(element, mutation.attribute);\n  } else if (mutation.kind === 'position') {\n    record = getElementPositionRecord(element);\n  }\n\n  if (!record) return;\n  record.mutations.push(mutation);\n  record.mutationRunner(record);\n} // get (existing) ElementPropertyRecord, remove mutation from it, then run\n\n\nfunction stopMutating(mutation, el) {\n  var record = null;\n\n  if (mutation.kind === 'html') {\n    record = getElementHTMLRecord(el);\n  } else if (mutation.kind === 'class') {\n    record = getElementClassRecord(el);\n  } else if (mutation.kind === 'attribute') {\n    record = getElementAttributeRecord(el, mutation.attribute);\n  } else if (mutation.kind === 'position') {\n    record = getElementPositionRecord(el);\n  }\n\n  if (!record) return;\n  var index = record.mutations.indexOf(mutation);\n  if (index !== -1) record.mutations.splice(index, 1);\n  record.mutationRunner(record);\n} // maintain list of elements associated with mutation\n\n\nfunction refreshElementsSet(mutation) {\n  // if a position mutation has already found an element to move, don't move\n  // any more elements\n  if (mutation.kind === 'position' && mutation.elements.size === 1) return;\n  var existingElements = new Set(mutation.elements);\n  var matchingElements = document.querySelectorAll(mutation.selector);\n  matchingElements.forEach(function (el) {\n    if (!existingElements.has(el)) {\n      mutation.elements.add(el);\n      startMutating(mutation, el);\n    }\n  });\n}\n\nfunction revertMutation(mutation) {\n  mutation.elements.forEach(function (el) {\n    return stopMutating(mutation, el);\n  });\n  mutation.elements.clear();\n  mutations[\"delete\"](mutation);\n}\n\nfunction refreshAllElementSets() {\n  mutations.forEach(refreshElementsSet);\n} // Observer for elements that don't exist in the DOM yet\n\n\nvar observer;\nfunction disconnectGlobalObserver() {\n  observer && observer.disconnect();\n}\nfunction connectGlobalObserver() {\n  if (typeof document === 'undefined') return;\n\n  if (!observer) {\n    observer = new MutationObserver(function () {\n      refreshAllElementSets();\n    });\n  }\n\n  refreshAllElementSets();\n  observer.observe(document.documentElement, {\n    childList: true,\n    subtree: true,\n    attributes: false,\n    characterData: false\n  });\n} // run on init\n\nconnectGlobalObserver();\n\nfunction newMutation(m) {\n  // Not in a browser\n  if (typeof document === 'undefined') return nullController; // add to global index of mutations\n\n  mutations.add(m); // run refresh on init to establish list of elements associated w/ mutation\n\n  refreshElementsSet(m);\n  return {\n    revert: function revert() {\n      revertMutation(m);\n    }\n  };\n}\n\nfunction html(selector, mutate) {\n  return newMutation({\n    kind: 'html',\n    elements: new Set(),\n    mutate: mutate,\n    selector: selector\n  });\n}\n\nfunction position(selector, mutate) {\n  return newMutation({\n    kind: 'position',\n    elements: new Set(),\n    mutate: mutate,\n    selector: selector\n  });\n}\n\nfunction classes(selector, mutate) {\n  return newMutation({\n    kind: 'class',\n    elements: new Set(),\n    mutate: mutate,\n    selector: selector\n  });\n}\n\nfunction attribute(selector, attribute, mutate) {\n  if (!validAttributeName.test(attribute)) return nullController;\n\n  if (attribute === 'class' || attribute === 'className') {\n    return classes(selector, function (classnames) {\n      var mutatedClassnames = mutate(Array.from(classnames).join(' '));\n      classnames.clear();\n      if (!mutatedClassnames) return;\n      mutatedClassnames.split(/\\s+/g).filter(Boolean).forEach(function (c) {\n        return classnames.add(c);\n      });\n    });\n  }\n\n  return newMutation({\n    kind: 'attribute',\n    attribute: attribute,\n    elements: new Set(),\n    mutate: mutate,\n    selector: selector\n  });\n}\n\nfunction declarative(_ref2) {\n  var selector = _ref2.selector,\n      action = _ref2.action,\n      value = _ref2.value,\n      attr = _ref2.attribute,\n      parentSelector = _ref2.parentSelector,\n      insertBeforeSelector = _ref2.insertBeforeSelector;\n\n  if (attr === 'html') {\n    if (action === 'append') {\n      return html(selector, function (val) {\n        return val + (value != null ? value : '');\n      });\n    } else if (action === 'set') {\n      return html(selector, function () {\n        return value != null ? value : '';\n      });\n    }\n  } else if (attr === 'class') {\n    if (action === 'append') {\n      return classes(selector, function (val) {\n        if (value) val.add(value);\n      });\n    } else if (action === 'remove') {\n      return classes(selector, function (val) {\n        if (value) val[\"delete\"](value);\n      });\n    } else if (action === 'set') {\n      return classes(selector, function (val) {\n        val.clear();\n        if (value) val.add(value);\n      });\n    }\n  } else if (attr === 'position') {\n    if (action === 'set' && parentSelector) {\n      return position(selector, function () {\n        return {\n          insertBeforeSelector: insertBeforeSelector,\n          parentSelector: parentSelector\n        };\n      });\n    }\n  } else {\n    if (action === 'append') {\n      return attribute(selector, attr, function (val) {\n        return val !== null ? val + (value != null ? value : '') : value != null ? value : '';\n      });\n    } else if (action === 'set') {\n      return attribute(selector, attr, function () {\n        return value != null ? value : '';\n      });\n    } else if (action === 'remove') {\n      return attribute(selector, attr, function () {\n        return null;\n      });\n    }\n  }\n\n  return nullController;\n}\n\nvar index = {\n  html: html,\n  classes: classes,\n  attribute: attribute,\n  position: position,\n  declarative: declarative\n};\n\nexport default index;\nexport { connectGlobalObserver, disconnectGlobalObserver, validAttributeName };\n//# sourceMappingURL=dom-mutator.esm.js.map\n","const polyfills = {\n  fetch: globalThis.fetch ? globalThis.fetch.bind(globalThis) : undefined,\n  SubtleCrypto: globalThis.crypto ? globalThis.crypto.subtle : undefined,\n  EventSource: globalThis.EventSource\n};\nexport function getPolyfills() {\n  return polyfills;\n}\nfunction hashFnv32a(str) {\n  let hval = 0x811c9dc5;\n  const l = str.length;\n  for (let i = 0; i < l; i++) {\n    hval ^= str.charCodeAt(i);\n    hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);\n  }\n  return hval >>> 0;\n}\nexport function hash(seed, value, version) {\n  // New unbiased hashing algorithm\n  if (version === 2) {\n    return hashFnv32a(hashFnv32a(seed + value) + \"\") % 10000 / 10000;\n  }\n  // Original biased hashing algorithm (keep for backwards compatibility)\n  if (version === 1) {\n    return hashFnv32a(value + seed) % 1000 / 1000;\n  }\n\n  // Unknown hash version\n  return null;\n}\nexport function getEqualWeights(n) {\n  if (n <= 0) return [];\n  return new Array(n).fill(1 / n);\n}\nexport function inRange(n, range) {\n  return n >= range[0] && n < range[1];\n}\nexport function inNamespace(hashValue, namespace) {\n  const n = hash(\"__\" + namespace[0], hashValue, 1);\n  if (n === null) return false;\n  return n >= namespace[1] && n < namespace[2];\n}\nexport function chooseVariation(n, ranges) {\n  for (let i = 0; i < ranges.length; i++) {\n    if (inRange(n, ranges[i])) {\n      return i;\n    }\n  }\n  return -1;\n}\nexport function getUrlRegExp(regexString) {\n  try {\n    const escaped = regexString.replace(/([^\\\\])\\//g, \"$1\\\\/\");\n    return new RegExp(escaped);\n  } catch (e) {\n    console.error(e);\n    return undefined;\n  }\n}\nexport function isURLTargeted(url, targets) {\n  if (!targets.length) return false;\n  let hasIncludeRules = false;\n  let isIncluded = false;\n  for (let i = 0; i < targets.length; i++) {\n    const match = _evalURLTarget(url, targets[i].type, targets[i].pattern);\n    if (targets[i].include === false) {\n      if (match) return false;\n    } else {\n      hasIncludeRules = true;\n      if (match) isIncluded = true;\n    }\n  }\n  return isIncluded || !hasIncludeRules;\n}\nfunction _evalSimpleUrlPart(actual, pattern, isPath) {\n  try {\n    // Escape special regex characters and change wildcard `_____` to `.*`\n    let escaped = pattern.replace(/[*.+?^${}()|[\\]\\\\]/g, \"\\\\$&\").replace(/_____/g, \".*\");\n    if (isPath) {\n      // When matching pathname, make leading/trailing slashes optional\n      escaped = \"\\\\/?\" + escaped.replace(/(^\\/|\\/$)/g, \"\") + \"\\\\/?\";\n    }\n    const regex = new RegExp(\"^\" + escaped + \"$\", \"i\");\n    return regex.test(actual);\n  } catch (e) {\n    return false;\n  }\n}\nfunction _evalSimpleUrlTarget(actual, pattern) {\n  try {\n    // If a protocol is missing, but a host is specified, add `https://` to the front\n    // Use \"_____\" as the wildcard since `*` is not a valid hostname in some browsers\n    const expected = new URL(pattern.replace(/^([^:/?]*)\\./i, \"https://$1.\").replace(/\\*/g, \"_____\"), \"https://_____\");\n\n    // Compare each part of the URL separately\n    const comps = [[actual.host, expected.host, false], [actual.pathname, expected.pathname, true]];\n    // We only want to compare hashes if it's explicitly being targeted\n    if (expected.hash) {\n      comps.push([actual.hash, expected.hash, false]);\n    }\n    expected.searchParams.forEach((v, k) => {\n      comps.push([actual.searchParams.get(k) || \"\", v, false]);\n    });\n\n    // If any comparisons fail, the whole thing fails\n    return !comps.some(data => !_evalSimpleUrlPart(data[0], data[1], data[2]));\n  } catch (e) {\n    return false;\n  }\n}\nfunction _evalURLTarget(url, type, pattern) {\n  try {\n    const parsed = new URL(url, \"https://_\");\n    if (type === \"regex\") {\n      const regex = getUrlRegExp(pattern);\n      if (!regex) return false;\n      return regex.test(parsed.href) || regex.test(parsed.href.substring(parsed.origin.length));\n    } else if (type === \"simple\") {\n      return _evalSimpleUrlTarget(parsed, pattern);\n    }\n    return false;\n  } catch (e) {\n    return false;\n  }\n}\nexport function getBucketRanges(numVariations, coverage, weights) {\n  coverage = coverage === undefined ? 1 : coverage;\n\n  // Make sure coverage is within bounds\n  if (coverage < 0) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.error(\"Experiment.coverage must be greater than or equal to 0\");\n    }\n    coverage = 0;\n  } else if (coverage > 1) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.error(\"Experiment.coverage must be less than or equal to 1\");\n    }\n    coverage = 1;\n  }\n\n  // Default to equal weights if missing or invalid\n  const equal = getEqualWeights(numVariations);\n  weights = weights || equal;\n  if (weights.length !== numVariations) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.error(\"Experiment.weights array must be the same length as Experiment.variations\");\n    }\n    weights = equal;\n  }\n\n  // If weights don't add up to 1 (or close to it), default to equal weights\n  const totalWeight = weights.reduce((w, sum) => sum + w, 0);\n  if (totalWeight < 0.99 || totalWeight > 1.01) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.error(\"Experiment.weights must add up to 1\");\n    }\n    weights = equal;\n  }\n\n  // Covert weights to ranges\n  let cumulative = 0;\n  return weights.map(w => {\n    const start = cumulative;\n    cumulative += w;\n    return [start, start + coverage * w];\n  });\n}\nexport function getQueryStringOverride(id, url, numVariations) {\n  if (!url) {\n    return null;\n  }\n  const search = url.split(\"?\")[1];\n  if (!search) {\n    return null;\n  }\n  const match = search.replace(/#.*/, \"\") // Get rid of anchor\n  .split(\"&\") // Split into key/value pairs\n  .map(kv => kv.split(\"=\", 2)).filter(_ref => {\n    let [k] = _ref;\n    return k === id;\n  }) // Look for key that matches the experiment id\n  .map(_ref2 => {\n    let [, v] = _ref2;\n    return parseInt(v);\n  }); // Parse the value into an integer\n\n  if (match.length > 0 && match[0] >= 0 && match[0] < numVariations) return match[0];\n  return null;\n}\nexport function isIncluded(include) {\n  try {\n    return include();\n  } catch (e) {\n    console.error(e);\n    return false;\n  }\n}\nconst base64ToBuf = b => Uint8Array.from(atob(b), c => c.charCodeAt(0));\nexport async function decrypt(encryptedString, decryptionKey, subtle) {\n  decryptionKey = decryptionKey || \"\";\n  subtle = subtle || globalThis.crypto && globalThis.crypto.subtle || polyfills.SubtleCrypto;\n  if (!subtle) {\n    throw new Error(\"No SubtleCrypto implementation found\");\n  }\n  try {\n    const key = await subtle.importKey(\"raw\", base64ToBuf(decryptionKey), {\n      name: \"AES-CBC\",\n      length: 128\n    }, true, [\"encrypt\", \"decrypt\"]);\n    const [iv, cipherText] = encryptedString.split(\".\");\n    const plainTextBuffer = await subtle.decrypt({\n      name: \"AES-CBC\",\n      iv: base64ToBuf(iv)\n    }, key, base64ToBuf(cipherText));\n    return new TextDecoder().decode(plainTextBuffer);\n  } catch (e) {\n    throw new Error(\"Failed to decrypt\");\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function toString(input) {\n  if (typeof input === \"string\") return input;\n  return JSON.stringify(input);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function paddedVersionString(input) {\n  if (typeof input === \"number\") {\n    input = input + \"\";\n  }\n  if (!input || typeof input !== \"string\") {\n    input = \"0\";\n  }\n  // Remove build info and leading `v` if any\n  // Split version into parts (both core version numbers and pre-release tags)\n  // \"v1.2.3-rc.1+build123\" -> [\"1\",\"2\",\"3\",\"rc\",\"1\"]\n  const parts = input.replace(/(^v|\\+.*$)/g, \"\").split(/[-.]/);\n\n  // If it's SemVer without a pre-release, add `~` to the end\n  // [\"1\",\"0\",\"0\"] -> [\"1\",\"0\",\"0\",\"~\"]\n  // \"~\" is the largest ASCII character, so this will make \"1.0.0\" greater than \"1.0.0-beta\" for example\n  if (parts.length === 3) {\n    parts.push(\"~\");\n  }\n\n  // Left pad each numeric part with spaces so string comparisons will work (\"9\">\"10\", but \" 9\"<\"10\")\n  // Then, join back together into a single string\n  return parts.map(v => v.match(/^[0-9]+$/) ? v.padStart(5, \" \") : v).join(\"-\");\n}\nexport function loadSDKVersion() {\n  let version;\n  try {\n    // @ts-expect-error right-hand value to be replaced by build with string literal\n    version = \"1.1.0\";\n  } catch (e) {\n    version = \"\";\n  }\n  return version;\n}\nexport function mergeQueryStrings(oldUrl, newUrl) {\n  let currUrl;\n  let redirectUrl;\n  try {\n    currUrl = new URL(oldUrl);\n    redirectUrl = new URL(newUrl);\n  } catch (e) {\n    console.error(\"Unable to merge query strings: \".concat(e));\n    return newUrl;\n  }\n  currUrl.searchParams.forEach((value, key) => {\n    // skip  if search param already exists in redirectUrl\n    if (redirectUrl.searchParams.has(key)) {\n      return;\n    }\n    redirectUrl.searchParams.set(key, value);\n  });\n  return redirectUrl.toString();\n}\nfunction isObj(x) {\n  return typeof x === \"object\" && x !== null;\n}\nexport function getAutoExperimentChangeType(exp) {\n  if (exp.urlPatterns && exp.variations.some(variation => isObj(variation) && \"urlRedirect\" in variation)) {\n    return \"redirect\";\n  } else if (exp.variations.some(variation => isObj(variation) && (variation.domMutations || \"js\" in variation || \"css\" in variation))) {\n    return \"visual\";\n  }\n  return \"unknown\";\n}\n//# sourceMappingURL=util.mjs.map","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { paddedVersionString } from \"./util.mjs\";\nconst _regexCache = {};\n\n// The top-level condition evaluation function\nexport function evalCondition(obj, condition,\n// Must be included for `condition` to correctly evaluate group Operators\nsavedGroups) {\n  savedGroups = savedGroups || {};\n  // Condition is an object, keys are either specific operators or object paths\n  // values are either arguments for operators or conditions for paths\n  for (const [k, v] of Object.entries(condition)) {\n    switch (k) {\n      case \"$or\":\n        if (!evalOr(obj, v, savedGroups)) return false;\n        break;\n      case \"$nor\":\n        if (evalOr(obj, v, savedGroups)) return false;\n        break;\n      case \"$and\":\n        if (!evalAnd(obj, v, savedGroups)) return false;\n        break;\n      case \"$not\":\n        if (evalCondition(obj, v, savedGroups)) return false;\n        break;\n      default:\n        if (!evalConditionValue(v, getPath(obj, k), savedGroups)) return false;\n    }\n  }\n  return true;\n}\n\n// Return value at dot-separated path of an object\nfunction getPath(obj, path) {\n  const parts = path.split(\".\");\n  let current = obj;\n  for (let i = 0; i < parts.length; i++) {\n    if (current && typeof current === \"object\" && parts[i] in current) {\n      current = current[parts[i]];\n    } else {\n      return null;\n    }\n  }\n  return current;\n}\n\n// Transform a regex string into a real RegExp object\nfunction getRegex(regex) {\n  if (!_regexCache[regex]) {\n    _regexCache[regex] = new RegExp(regex.replace(/([^\\\\])\\//g, \"$1\\\\/\"));\n  }\n  return _regexCache[regex];\n}\n\n// Evaluate a single value against a condition\nfunction evalConditionValue(condition, value, savedGroups) {\n  // Simple equality comparisons\n  if (typeof condition === \"string\") {\n    return value + \"\" === condition;\n  }\n  if (typeof condition === \"number\") {\n    return value * 1 === condition;\n  }\n  if (typeof condition === \"boolean\") {\n    return !!value === condition;\n  }\n  if (condition === null) {\n    return value === null;\n  }\n  if (Array.isArray(condition) || !isOperatorObject(condition)) {\n    return JSON.stringify(value) === JSON.stringify(condition);\n  }\n\n  // This is a special operator condition and we should evaluate each one separately\n  for (const op in condition) {\n    if (!evalOperatorCondition(op, value, condition[op], savedGroups)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// If the object has only keys that start with '$'\nfunction isOperatorObject(obj) {\n  const keys = Object.keys(obj);\n  return keys.length > 0 && keys.filter(k => k[0] === \"$\").length === keys.length;\n}\n\n// Return the data type of a value\nfunction getType(v) {\n  if (v === null) return \"null\";\n  if (Array.isArray(v)) return \"array\";\n  const t = typeof v;\n  if ([\"string\", \"number\", \"boolean\", \"object\", \"undefined\"].includes(t)) {\n    return t;\n  }\n  return \"unknown\";\n}\n\n// At least one element of actual must match the expected condition/value\nfunction elemMatch(actual, expected, savedGroups) {\n  if (!Array.isArray(actual)) return false;\n  const check = isOperatorObject(expected) ? v => evalConditionValue(expected, v, savedGroups) : v => evalCondition(v, expected, savedGroups);\n  for (let i = 0; i < actual.length; i++) {\n    if (actual[i] && check(actual[i])) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction isIn(actual, expected) {\n  // Do an intersection if attribute is an array\n  if (Array.isArray(actual)) {\n    return actual.some(el => expected.includes(el));\n  }\n  return expected.includes(actual);\n}\n\n// Evaluate a single operator condition\nfunction evalOperatorCondition(operator, actual, expected, savedGroups) {\n  switch (operator) {\n    case \"$veq\":\n      return paddedVersionString(actual) === paddedVersionString(expected);\n    case \"$vne\":\n      return paddedVersionString(actual) !== paddedVersionString(expected);\n    case \"$vgt\":\n      return paddedVersionString(actual) > paddedVersionString(expected);\n    case \"$vgte\":\n      return paddedVersionString(actual) >= paddedVersionString(expected);\n    case \"$vlt\":\n      return paddedVersionString(actual) < paddedVersionString(expected);\n    case \"$vlte\":\n      return paddedVersionString(actual) <= paddedVersionString(expected);\n    case \"$eq\":\n      return actual === expected;\n    case \"$ne\":\n      return actual !== expected;\n    case \"$lt\":\n      return actual < expected;\n    case \"$lte\":\n      return actual <= expected;\n    case \"$gt\":\n      return actual > expected;\n    case \"$gte\":\n      return actual >= expected;\n    case \"$exists\":\n      // Using `!=` and `==` instead of strict checks so it also matches for undefined\n      return expected ? actual != null : actual == null;\n    case \"$in\":\n      if (!Array.isArray(expected)) return false;\n      return isIn(actual, expected);\n    case \"$inGroup\":\n      return isIn(actual, savedGroups[expected] || []);\n    case \"$notInGroup\":\n      return !isIn(actual, savedGroups[expected] || []);\n    case \"$nin\":\n      if (!Array.isArray(expected)) return false;\n      return !isIn(actual, expected);\n    case \"$not\":\n      return !evalConditionValue(expected, actual, savedGroups);\n    case \"$size\":\n      if (!Array.isArray(actual)) return false;\n      return evalConditionValue(expected, actual.length, savedGroups);\n    case \"$elemMatch\":\n      return elemMatch(actual, expected, savedGroups);\n    case \"$all\":\n      if (!Array.isArray(actual)) return false;\n      for (let i = 0; i < expected.length; i++) {\n        let passed = false;\n        for (let j = 0; j < actual.length; j++) {\n          if (evalConditionValue(expected[i], actual[j], savedGroups)) {\n            passed = true;\n            break;\n          }\n        }\n        if (!passed) return false;\n      }\n      return true;\n    case \"$regex\":\n      try {\n        return getRegex(expected).test(actual);\n      } catch (e) {\n        return false;\n      }\n    case \"$type\":\n      return getType(actual) === expected;\n    default:\n      console.error(\"Unknown operator: \" + operator);\n      return false;\n  }\n}\n\n// Recursive $or rule\nfunction evalOr(obj, conditions, savedGroups) {\n  if (!conditions.length) return true;\n  for (let i = 0; i < conditions.length; i++) {\n    if (evalCondition(obj, conditions[i], savedGroups)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n// Recursive $and rule\nfunction evalAnd(obj, conditions, savedGroups) {\n  for (let i = 0; i < conditions.length; i++) {\n    if (!evalCondition(obj, conditions[i], savedGroups)) {\n      return false;\n    }\n  }\n  return true;\n}\n//# sourceMappingURL=mongrule.mjs.map","import { getPolyfills } from \"./util.mjs\";\n// Config settings\nconst cacheSettings = {\n  // Consider a fetch stale after 1 minute\n  staleTTL: 1000 * 60,\n  // Max time to keep a fetch in cache (24 hours default)\n  maxAge: 1000 * 60 * 60 * 24,\n  cacheKey: \"gbFeaturesCache\",\n  backgroundSync: true,\n  maxEntries: 10,\n  disableIdleStreams: false,\n  idleStreamInterval: 20000,\n  disableCache: false\n};\nconst polyfills = getPolyfills();\nexport const helpers = {\n  fetchFeaturesCall: _ref => {\n    let {\n      host,\n      clientKey,\n      headers\n    } = _ref;\n    return polyfills.fetch(\"\".concat(host, \"/api/features/\").concat(clientKey), {\n      headers\n    });\n  },\n  fetchRemoteEvalCall: _ref2 => {\n    let {\n      host,\n      clientKey,\n      payload,\n      headers\n    } = _ref2;\n    const options = {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        ...headers\n      },\n      body: JSON.stringify(payload)\n    };\n    return polyfills.fetch(\"\".concat(host, \"/api/eval/\").concat(clientKey), options);\n  },\n  eventSourceCall: _ref3 => {\n    let {\n      host,\n      clientKey,\n      headers\n    } = _ref3;\n    if (headers) {\n      return new polyfills.EventSource(\"\".concat(host, \"/sub/\").concat(clientKey), {\n        headers\n      });\n    }\n    return new polyfills.EventSource(\"\".concat(host, \"/sub/\").concat(clientKey));\n  },\n  startIdleListener: () => {\n    let idleTimeout;\n    const isBrowser = typeof window !== \"undefined\" && typeof document !== \"undefined\";\n    if (!isBrowser) return;\n    const onVisibilityChange = () => {\n      if (document.visibilityState === \"visible\") {\n        window.clearTimeout(idleTimeout);\n        onVisible();\n      } else if (document.visibilityState === \"hidden\") {\n        idleTimeout = window.setTimeout(onHidden, cacheSettings.idleStreamInterval);\n      }\n    };\n    document.addEventListener(\"visibilitychange\", onVisibilityChange);\n    return () => document.removeEventListener(\"visibilitychange\", onVisibilityChange);\n  },\n  stopIdleListener: () => {\n    // No-op, replaced by startIdleListener\n  }\n};\ntry {\n  if (globalThis.localStorage) {\n    polyfills.localStorage = globalThis.localStorage;\n  }\n} catch (e) {\n  // Ignore localStorage errors\n}\n\n// Global state\nconst subscribedInstances = new Map();\nlet cacheInitialized = false;\nconst cache = new Map();\nconst activeFetches = new Map();\nconst streams = new Map();\nconst supportsSSE = new Set();\n\n// Public functions\nexport function setPolyfills(overrides) {\n  Object.assign(polyfills, overrides);\n}\nexport function configureCache(overrides) {\n  Object.assign(cacheSettings, overrides);\n  if (!cacheSettings.backgroundSync) {\n    clearAutoRefresh();\n  }\n}\nexport async function clearCache() {\n  cache.clear();\n  activeFetches.clear();\n  clearAutoRefresh();\n  cacheInitialized = false;\n  await updatePersistentCache();\n}\n\n// Get or fetch features and refresh the SDK instance\nexport async function refreshFeatures(_ref4) {\n  let {\n    instance,\n    timeout,\n    skipCache,\n    allowStale,\n    backgroundSync\n  } = _ref4;\n  if (!backgroundSync) {\n    cacheSettings.backgroundSync = false;\n  }\n  return fetchFeaturesWithCache({\n    instance,\n    allowStale,\n    timeout,\n    skipCache\n  });\n}\n\n// Subscribe a GrowthBook instance to feature changes\nexport function subscribe(instance) {\n  const key = getKey(instance);\n  const subs = subscribedInstances.get(key) || new Set();\n  subs.add(instance);\n  subscribedInstances.set(key, subs);\n}\nexport function unsubscribe(instance) {\n  subscribedInstances.forEach(s => s.delete(instance));\n}\nexport function onHidden() {\n  streams.forEach(channel => {\n    if (!channel) return;\n    channel.state = \"idle\";\n    disableChannel(channel);\n  });\n}\nexport function onVisible() {\n  streams.forEach(channel => {\n    if (!channel) return;\n    if (channel.state !== \"idle\") return;\n    enableChannel(channel);\n  });\n}\n\n// Private functions\n\nasync function updatePersistentCache() {\n  try {\n    if (!polyfills.localStorage) return;\n    await polyfills.localStorage.setItem(cacheSettings.cacheKey, JSON.stringify(Array.from(cache.entries())));\n  } catch (e) {\n    // Ignore localStorage errors\n  }\n}\n\n// SWR wrapper for fetching features. May indirectly or directly start SSE streaming.\nasync function fetchFeaturesWithCache(_ref5) {\n  let {\n    instance,\n    allowStale,\n    timeout,\n    skipCache\n  } = _ref5;\n  const key = getKey(instance);\n  const cacheKey = getCacheKey(instance);\n  const now = new Date();\n  const minStaleAt = new Date(now.getTime() - cacheSettings.maxAge + cacheSettings.staleTTL);\n  await initializeCache();\n  const existing = !cacheSettings.disableCache && !skipCache ? cache.get(cacheKey) : undefined;\n  if (existing && (allowStale || existing.staleAt > now) && existing.staleAt > minStaleAt) {\n    // Restore from cache whether SSE is supported\n    if (existing.sse) supportsSSE.add(key);\n\n    // Reload features in the background if stale\n    if (existing.staleAt < now) {\n      fetchFeatures(instance);\n    }\n    // Otherwise, if we don't need to refresh now, start a background sync\n    else {\n      startAutoRefresh(instance);\n    }\n    return {\n      data: existing.data,\n      success: true,\n      source: \"cache\"\n    };\n  } else {\n    const res = await promiseTimeout(fetchFeatures(instance), timeout);\n    return res || {\n      data: null,\n      success: false,\n      source: \"timeout\",\n      error: new Error(\"Timeout\")\n    };\n  }\n}\nfunction getKey(instance) {\n  const [apiHost, clientKey] = instance.getApiInfo();\n  return \"\".concat(apiHost, \"||\").concat(clientKey);\n}\nfunction getCacheKey(instance) {\n  const baseKey = getKey(instance);\n  if (!instance.isRemoteEval()) return baseKey;\n  const attributes = instance.getAttributes();\n  const cacheKeyAttributes = instance.getCacheKeyAttributes() || Object.keys(instance.getAttributes());\n  const ca = {};\n  cacheKeyAttributes.forEach(key => {\n    ca[key] = attributes[key];\n  });\n  const fv = instance.getForcedVariations();\n  const url = instance.getUrl();\n  return \"\".concat(baseKey, \"||\").concat(JSON.stringify({\n    ca,\n    fv,\n    url\n  }));\n}\n\n// Guarantee the promise always resolves within {timeout} ms\n// Resolved value will be `null` when there's an error or it takes too long\n// Note: The promise will continue running in the background, even if the timeout is hit\nfunction promiseTimeout(promise, timeout) {\n  return new Promise(resolve => {\n    let resolved = false;\n    let timer;\n    const finish = data => {\n      if (resolved) return;\n      resolved = true;\n      timer && clearTimeout(timer);\n      resolve(data || null);\n    };\n    if (timeout) {\n      timer = setTimeout(() => finish(), timeout);\n    }\n    promise.then(data => finish(data)).catch(() => finish());\n  });\n}\n\n// Populate cache from localStorage (if available)\nasync function initializeCache() {\n  if (cacheInitialized) return;\n  cacheInitialized = true;\n  try {\n    if (polyfills.localStorage) {\n      const value = await polyfills.localStorage.getItem(cacheSettings.cacheKey);\n      if (!cacheSettings.disableCache && value) {\n        const parsed = JSON.parse(value);\n        if (parsed && Array.isArray(parsed)) {\n          parsed.forEach(_ref6 => {\n            let [key, data] = _ref6;\n            cache.set(key, {\n              ...data,\n              staleAt: new Date(data.staleAt)\n            });\n          });\n        }\n        cleanupCache();\n      }\n    }\n  } catch (e) {\n    // Ignore localStorage errors\n  }\n  if (!cacheSettings.disableIdleStreams) {\n    const cleanupFn = helpers.startIdleListener();\n    if (cleanupFn) {\n      helpers.stopIdleListener = cleanupFn;\n    }\n  }\n}\n\n// Enforce the maxEntries limit\nfunction cleanupCache() {\n  const entriesWithTimestamps = Array.from(cache.entries()).map(_ref7 => {\n    let [key, value] = _ref7;\n    return {\n      key,\n      staleAt: value.staleAt.getTime()\n    };\n  }).sort((a, b) => a.staleAt - b.staleAt);\n  const entriesToRemoveCount = Math.min(Math.max(0, cache.size - cacheSettings.maxEntries), cache.size);\n  for (let i = 0; i < entriesToRemoveCount; i++) {\n    cache.delete(entriesWithTimestamps[i].key);\n  }\n}\n\n// Called whenever new features are fetched from the API\nfunction onNewFeatureData(key, cacheKey, data) {\n  // If contents haven't changed, ignore the update, extend the stale TTL\n  const version = data.dateUpdated || \"\";\n  const staleAt = new Date(Date.now() + cacheSettings.staleTTL);\n  const existing = !cacheSettings.disableCache ? cache.get(cacheKey) : undefined;\n  if (existing && version && existing.version === version) {\n    existing.staleAt = staleAt;\n    updatePersistentCache();\n    return;\n  }\n  if (!cacheSettings.disableCache) {\n    // Update in-memory cache\n    cache.set(cacheKey, {\n      data,\n      version,\n      staleAt,\n      sse: supportsSSE.has(key)\n    });\n    cleanupCache();\n  }\n  // Update local storage (don't await this, just update asynchronously)\n  updatePersistentCache();\n\n  // Update features for all subscribed GrowthBook instances\n  const instances = subscribedInstances.get(key);\n  instances && instances.forEach(instance => refreshInstance(instance, data));\n}\nasync function refreshInstance(instance, data) {\n  await instance.setPayload(data || instance.getPayload());\n}\n\n// Fetch the features payload from helper function or from in-mem injected payload\nasync function fetchFeatures(instance) {\n  const {\n    apiHost,\n    apiRequestHeaders\n  } = instance.getApiHosts();\n  const clientKey = instance.getClientKey();\n  const remoteEval = instance.isRemoteEval();\n  const key = getKey(instance);\n  const cacheKey = getCacheKey(instance);\n  let promise = activeFetches.get(cacheKey);\n  if (!promise) {\n    const fetcher = remoteEval ? helpers.fetchRemoteEvalCall({\n      host: apiHost,\n      clientKey,\n      payload: {\n        attributes: instance.getAttributes(),\n        forcedVariations: instance.getForcedVariations(),\n        forcedFeatures: Array.from(instance.getForcedFeatures().entries()),\n        url: instance.getUrl()\n      },\n      headers: apiRequestHeaders\n    }) : helpers.fetchFeaturesCall({\n      host: apiHost,\n      clientKey,\n      headers: apiRequestHeaders\n    });\n\n    // TODO: auto-retry if status code indicates a temporary error\n    promise = fetcher.then(res => {\n      if (!res.ok) {\n        throw new Error(\"HTTP error: \".concat(res.status));\n      }\n      if (res.headers.get(\"x-sse-support\") === \"enabled\") {\n        supportsSSE.add(key);\n      }\n      return res.json();\n    }).then(data => {\n      onNewFeatureData(key, cacheKey, data);\n      startAutoRefresh(instance);\n      activeFetches.delete(cacheKey);\n      return {\n        data,\n        success: true,\n        source: \"network\"\n      };\n    }).catch(e => {\n      process.env.NODE_ENV !== \"production\" && instance.log(\"Error fetching features\", {\n        apiHost,\n        clientKey,\n        error: e ? e.message : null\n      });\n      activeFetches.delete(cacheKey);\n      return {\n        data: null,\n        source: \"error\",\n        success: false,\n        error: e\n      };\n    });\n    activeFetches.set(cacheKey, promise);\n  }\n  return promise;\n}\n\n// Start SSE streaming, listens to feature payload changes and triggers a refresh or re-fetch\nexport function startAutoRefresh(instance) {\n  let forceSSE = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  const key = getKey(instance);\n  const cacheKey = getCacheKey(instance);\n  const {\n    streamingHost,\n    streamingHostRequestHeaders\n  } = instance.getApiHosts();\n  const clientKey = instance.getClientKey();\n  if (forceSSE) {\n    supportsSSE.add(key);\n  }\n  if (cacheSettings.backgroundSync && supportsSSE.has(key) && polyfills.EventSource) {\n    if (streams.has(key)) return;\n    const channel = {\n      src: null,\n      host: streamingHost,\n      clientKey,\n      headers: streamingHostRequestHeaders,\n      cb: event => {\n        try {\n          if (event.type === \"features-updated\") {\n            const instances = subscribedInstances.get(key);\n            instances && instances.forEach(instance => {\n              fetchFeatures(instance);\n            });\n          } else if (event.type === \"features\") {\n            const json = JSON.parse(event.data);\n            onNewFeatureData(key, cacheKey, json);\n          }\n          // Reset error count on success\n          channel.errors = 0;\n        } catch (e) {\n          process.env.NODE_ENV !== \"production\" && instance.log(\"SSE Error\", {\n            streamingHost,\n            clientKey,\n            error: e ? e.message : null\n          });\n          onSSEError(channel);\n        }\n      },\n      errors: 0,\n      state: \"active\"\n    };\n    streams.set(key, channel);\n    enableChannel(channel);\n  }\n}\nfunction onSSEError(channel) {\n  if (channel.state === \"idle\") return;\n  channel.errors++;\n  if (channel.errors > 3 || channel.src && channel.src.readyState === 2) {\n    // exponential backoff after 4 errors, with jitter\n    const delay = Math.pow(3, channel.errors - 3) * (1000 + Math.random() * 1000);\n    disableChannel(channel);\n    setTimeout(() => {\n      if ([\"idle\", \"active\"].includes(channel.state)) return;\n      enableChannel(channel);\n    }, Math.min(delay, 300000)); // 5 minutes max\n  }\n}\n\nfunction disableChannel(channel) {\n  if (!channel.src) return;\n  channel.src.onopen = null;\n  channel.src.onerror = null;\n  channel.src.close();\n  channel.src = null;\n  if (channel.state === \"active\") {\n    channel.state = \"disabled\";\n  }\n}\nfunction enableChannel(channel) {\n  channel.src = helpers.eventSourceCall({\n    host: channel.host,\n    clientKey: channel.clientKey,\n    headers: channel.headers\n  });\n  channel.state = \"active\";\n  channel.src.addEventListener(\"features\", channel.cb);\n  channel.src.addEventListener(\"features-updated\", channel.cb);\n  channel.src.onerror = () => onSSEError(channel);\n  channel.src.onopen = () => {\n    channel.errors = 0;\n  };\n}\nfunction destroyChannel(channel, key) {\n  disableChannel(channel);\n  streams.delete(key);\n}\nfunction clearAutoRefresh() {\n  // Clear list of which keys are auto-updated\n  supportsSSE.clear();\n\n  // Stop listening for any SSE events\n  streams.forEach(destroyChannel);\n\n  // Remove all references to GrowthBook instances\n  subscribedInstances.clear();\n\n  // Run the idle stream cleanup function\n  helpers.stopIdleListener();\n}\n//# sourceMappingURL=feature-repository.mjs.map","import mutate from \"dom-mutator\";\nimport { chooseVariation, decrypt, getAutoExperimentChangeType, getBucketRanges, getQueryStringOverride, getUrlRegExp, hash, inNamespace, inRange, isIncluded, isURLTargeted, loadSDKVersion, mergeQueryStrings, toString } from \"./util.mjs\";\nimport { evalCondition } from \"./mongrule.mjs\";\nimport { refreshFeatures, startAutoRefresh, subscribe, unsubscribe } from \"./feature-repository.mjs\";\nconst isBrowser = typeof window !== \"undefined\" && typeof document !== \"undefined\";\nconst SDK_VERSION = loadSDKVersion();\nexport class GrowthBook {\n  // context is technically private, but some tools depend on it so we can't mangle the name\n  // _ctx below is a clone of this property that we use internally\n\n  // Properties and methods that start with \"_\" are mangled by Terser (saves ~150 bytes)\n\n  // eslint-disable-next-line\n\n  constructor(context) {\n    context = context || {};\n    // These properties are all initialized in the constructor instead of above\n    // This saves ~80 bytes in the final output\n    this.version = SDK_VERSION;\n    this._ctx = this.context = context;\n    this._renderer = context.renderer || null;\n    this._trackedExperiments = new Set();\n    this._completedChangeIds = new Set();\n    this._trackedFeatures = {};\n    this.debug = !!context.debug;\n    this._subscriptions = new Set();\n    this._rtQueue = [];\n    this._rtTimer = 0;\n    this.ready = false;\n    this._assigned = new Map();\n    this._forcedFeatureValues = new Map();\n    this._attributeOverrides = {};\n    this._activeAutoExperiments = new Map();\n    this._triggeredExpKeys = new Set();\n    this._initialized = false;\n    this._redirectedUrl = \"\";\n    this._deferredTrackingCalls = new Map();\n    this._autoExperimentsAllowed = !context.disableExperimentsOnLoad;\n    if (context.remoteEval) {\n      if (context.decryptionKey) {\n        throw new Error(\"Encryption is not available for remoteEval\");\n      }\n      if (!context.clientKey) {\n        throw new Error(\"Missing clientKey\");\n      }\n      let isGbHost = false;\n      try {\n        isGbHost = !!new URL(context.apiHost || \"\").hostname.match(/growthbook\\.io$/i);\n      } catch (e) {\n        // ignore invalid URLs\n      }\n      if (isGbHost) {\n        throw new Error(\"Cannot use remoteEval on GrowthBook Cloud\");\n      }\n    } else {\n      if (context.cacheKeyAttributes) {\n        throw new Error(\"cacheKeyAttributes are only used for remoteEval\");\n      }\n    }\n    if (context.features) {\n      this.ready = true;\n    }\n    if (isBrowser && context.enableDevMode) {\n      window._growthbook = this;\n      document.dispatchEvent(new Event(\"gbloaded\"));\n    }\n    if (context.experiments) {\n      this.ready = true;\n      this._updateAllAutoExperiments();\n    } else if (context.antiFlicker) {\n      this._setAntiFlicker();\n    }\n\n    // Hydrate sticky bucket service\n    if (this._ctx.stickyBucketService && this._ctx.stickyBucketAssignmentDocs) {\n      for (const key in this._ctx.stickyBucketAssignmentDocs) {\n        const doc = this._ctx.stickyBucketAssignmentDocs[key];\n        if (doc) {\n          this._ctx.stickyBucketService.saveAssignments(doc).catch(() => {\n            // Ignore hydration errors\n          });\n        }\n      }\n    }\n\n    // Legacy - passing in features/experiments into the constructor instead of using init\n    if (this.ready) {\n      this.refreshStickyBuckets(this.getPayload());\n    }\n  }\n  async setPayload(payload) {\n    this._payload = payload;\n    const data = await this.decryptPayload(payload);\n    this._decryptedPayload = data;\n    await this.refreshStickyBuckets(data);\n    if (data.features) {\n      this._ctx.features = data.features;\n    }\n    if (data.savedGroups) {\n      this._ctx.savedGroups = data.savedGroups;\n    }\n    if (data.experiments) {\n      this._ctx.experiments = data.experiments;\n      this._updateAllAutoExperiments();\n    }\n    this.ready = true;\n    this._render();\n  }\n  initSync(options) {\n    this._initialized = true;\n    const payload = options.payload;\n    if (payload.encryptedExperiments || payload.encryptedFeatures) {\n      throw new Error(\"initSync does not support encrypted payloads\");\n    }\n    if (this._ctx.stickyBucketService && !this._ctx.stickyBucketAssignmentDocs) {\n      throw new Error(\"initSync requires you to pass stickyBucketAssignmentDocs into the GrowthBook constructor\");\n    }\n    this._payload = payload;\n    this._decryptedPayload = payload;\n    if (payload.features) {\n      this._ctx.features = payload.features;\n    }\n    if (payload.experiments) {\n      this._ctx.experiments = payload.experiments;\n      this._updateAllAutoExperiments();\n    }\n    this.ready = true;\n    if (options.streaming) {\n      if (!this._ctx.clientKey) {\n        throw new Error(\"Must specify clientKey to enable streaming\");\n      }\n      startAutoRefresh(this, true);\n      subscribe(this);\n    }\n    return this;\n  }\n  async init(options) {\n    this._initialized = true;\n    options = options || {};\n    if (options.payload) {\n      await this.setPayload(options.payload);\n      if (options.streaming) {\n        if (!this._ctx.clientKey) {\n          throw new Error(\"Must specify clientKey to enable streaming\");\n        }\n        startAutoRefresh(this, true);\n        subscribe(this);\n      }\n      return {\n        success: true,\n        source: \"init\"\n      };\n    } else {\n      const {\n        data,\n        ...res\n      } = await this._refresh({\n        ...options,\n        allowStale: true\n      });\n      if (options.streaming) {\n        subscribe(this);\n      }\n      await this.setPayload(data || {});\n      return res;\n    }\n  }\n\n  /** @deprecated Use {@link init} */\n  async loadFeatures(options) {\n    this._initialized = true;\n    options = options || {};\n    if (options.autoRefresh) {\n      // interpret deprecated autoRefresh option as subscribeToChanges\n      this._ctx.subscribeToChanges = true;\n    }\n    const {\n      data\n    } = await this._refresh({\n      ...options,\n      allowStale: true\n    });\n    await this.setPayload(data || {});\n    if (this._canSubscribe()) {\n      subscribe(this);\n    }\n  }\n  async refreshFeatures(options) {\n    const res = await this._refresh({\n      ...(options || {}),\n      allowStale: false\n    });\n    if (res.data) {\n      await this.setPayload(res.data);\n    }\n  }\n  getApiInfo() {\n    return [this.getApiHosts().apiHost, this.getClientKey()];\n  }\n  getApiHosts() {\n    const defaultHost = this._ctx.apiHost || \"https://cdn.growthbook.io\";\n    return {\n      apiHost: defaultHost.replace(/\\/*$/, \"\"),\n      streamingHost: (this._ctx.streamingHost || defaultHost).replace(/\\/*$/, \"\"),\n      apiRequestHeaders: this._ctx.apiHostRequestHeaders,\n      streamingHostRequestHeaders: this._ctx.streamingHostRequestHeaders\n    };\n  }\n  getClientKey() {\n    return this._ctx.clientKey || \"\";\n  }\n  getPayload() {\n    return this._payload || {\n      features: this.getFeatures(),\n      experiments: this.getExperiments()\n    };\n  }\n  getDecryptedPayload() {\n    return this._decryptedPayload || this.getPayload();\n  }\n  isRemoteEval() {\n    return this._ctx.remoteEval || false;\n  }\n  getCacheKeyAttributes() {\n    return this._ctx.cacheKeyAttributes;\n  }\n  async _refresh(_ref) {\n    var _ref2;\n    let {\n      timeout,\n      skipCache,\n      allowStale,\n      streaming\n    } = _ref;\n    if (!this._ctx.clientKey) {\n      throw new Error(\"Missing clientKey\");\n    }\n    // Trigger refresh in feature repository\n    return refreshFeatures({\n      instance: this,\n      timeout,\n      skipCache: skipCache || this._ctx.disableCache,\n      allowStale,\n      backgroundSync: (_ref2 = streaming !== null && streaming !== void 0 ? streaming : this._ctx.backgroundSync) !== null && _ref2 !== void 0 ? _ref2 : true\n    });\n  }\n  _render() {\n    if (this._renderer) {\n      try {\n        this._renderer();\n      } catch (e) {\n        console.error(\"Failed to render\", e);\n      }\n    }\n  }\n\n  /** @deprecated Use {@link setPayload} */\n  setFeatures(features) {\n    this._ctx.features = features;\n    this.ready = true;\n    this._render();\n  }\n\n  /** @deprecated Use {@link setPayload} */\n  async setEncryptedFeatures(encryptedString, decryptionKey, subtle) {\n    const featuresJSON = await decrypt(encryptedString, decryptionKey || this._ctx.decryptionKey, subtle);\n    this.setFeatures(JSON.parse(featuresJSON));\n  }\n\n  /** @deprecated Use {@link setPayload} */\n  setExperiments(experiments) {\n    this._ctx.experiments = experiments;\n    this.ready = true;\n    this._updateAllAutoExperiments();\n  }\n\n  /** @deprecated Use {@link setPayload} */\n  async setEncryptedExperiments(encryptedString, decryptionKey, subtle) {\n    const experimentsJSON = await decrypt(encryptedString, decryptionKey || this._ctx.decryptionKey, subtle);\n    this.setExperiments(JSON.parse(experimentsJSON));\n  }\n  async decryptPayload(data, decryptionKey, subtle) {\n    data = {\n      ...data\n    };\n    if (data.encryptedFeatures) {\n      try {\n        data.features = JSON.parse(await decrypt(data.encryptedFeatures, decryptionKey || this._ctx.decryptionKey, subtle));\n      } catch (e) {\n        console.error(e);\n      }\n      delete data.encryptedFeatures;\n    }\n    if (data.encryptedExperiments) {\n      try {\n        data.experiments = JSON.parse(await decrypt(data.encryptedExperiments, decryptionKey || this._ctx.decryptionKey, subtle));\n      } catch (e) {\n        console.error(e);\n      }\n      delete data.encryptedExperiments;\n    }\n    if (data.encryptedSavedGroups) {\n      try {\n        data.savedGroups = JSON.parse(await decrypt(data.encryptedSavedGroups, decryptionKey || this._ctx.decryptionKey, subtle));\n      } catch (e) {\n        console.error(e);\n      }\n      delete data.encryptedSavedGroups;\n    }\n    return data;\n  }\n  async setAttributes(attributes) {\n    this._ctx.attributes = attributes;\n    if (this._ctx.stickyBucketService) {\n      await this.refreshStickyBuckets();\n    }\n    if (this._ctx.remoteEval) {\n      await this._refreshForRemoteEval();\n      return;\n    }\n    this._render();\n    this._updateAllAutoExperiments();\n  }\n  async updateAttributes(attributes) {\n    return this.setAttributes({\n      ...this._ctx.attributes,\n      ...attributes\n    });\n  }\n  async setAttributeOverrides(overrides) {\n    this._attributeOverrides = overrides;\n    if (this._ctx.stickyBucketService) {\n      await this.refreshStickyBuckets();\n    }\n    if (this._ctx.remoteEval) {\n      await this._refreshForRemoteEval();\n      return;\n    }\n    this._render();\n    this._updateAllAutoExperiments();\n  }\n  async setForcedVariations(vars) {\n    this._ctx.forcedVariations = vars || {};\n    if (this._ctx.remoteEval) {\n      await this._refreshForRemoteEval();\n      return;\n    }\n    this._render();\n    this._updateAllAutoExperiments();\n  }\n\n  // eslint-disable-next-line\n  setForcedFeatures(map) {\n    this._forcedFeatureValues = map;\n    this._render();\n  }\n  async setURL(url) {\n    this._ctx.url = url;\n    this._redirectedUrl = \"\";\n    if (this._ctx.remoteEval) {\n      await this._refreshForRemoteEval();\n      this._updateAllAutoExperiments(true);\n      return;\n    }\n    this._updateAllAutoExperiments(true);\n  }\n  getAttributes() {\n    return {\n      ...this._ctx.attributes,\n      ...this._attributeOverrides\n    };\n  }\n  getForcedVariations() {\n    return this._ctx.forcedVariations || {};\n  }\n  getForcedFeatures() {\n    // eslint-disable-next-line\n    return this._forcedFeatureValues || new Map();\n  }\n  getStickyBucketAssignmentDocs() {\n    return this._ctx.stickyBucketAssignmentDocs || {};\n  }\n  getUrl() {\n    return this._ctx.url || \"\";\n  }\n  getFeatures() {\n    return this._ctx.features || {};\n  }\n  getExperiments() {\n    return this._ctx.experiments || [];\n  }\n  getCompletedChangeIds() {\n    return Array.from(this._completedChangeIds);\n  }\n  subscribe(cb) {\n    this._subscriptions.add(cb);\n    return () => {\n      this._subscriptions.delete(cb);\n    };\n  }\n  _canSubscribe() {\n    var _this$_ctx$background;\n    return ((_this$_ctx$background = this._ctx.backgroundSync) !== null && _this$_ctx$background !== void 0 ? _this$_ctx$background : true) && this._ctx.subscribeToChanges;\n  }\n  async _refreshForRemoteEval() {\n    if (!this._ctx.remoteEval) return;\n    if (!this._initialized) return;\n    const res = await this._refresh({\n      allowStale: false\n    });\n    if (res.data) {\n      await this.setPayload(res.data);\n    }\n  }\n  getAllResults() {\n    return new Map(this._assigned);\n  }\n  destroy() {\n    // Release references to save memory\n    this._subscriptions.clear();\n    this._assigned.clear();\n    this._trackedExperiments.clear();\n    this._completedChangeIds.clear();\n    this._deferredTrackingCalls.clear();\n    this._trackedFeatures = {};\n    this._rtQueue = [];\n    this._payload = undefined;\n    if (this._rtTimer) {\n      clearTimeout(this._rtTimer);\n    }\n    unsubscribe(this);\n    if (isBrowser && window._growthbook === this) {\n      delete window._growthbook;\n    }\n\n    // Undo any active auto experiments\n    this._activeAutoExperiments.forEach(exp => {\n      exp.undo();\n    });\n    this._activeAutoExperiments.clear();\n    this._triggeredExpKeys.clear();\n  }\n  setRenderer(renderer) {\n    this._renderer = renderer;\n  }\n  forceVariation(key, variation) {\n    this._ctx.forcedVariations = this._ctx.forcedVariations || {};\n    this._ctx.forcedVariations[key] = variation;\n    if (this._ctx.remoteEval) {\n      this._refreshForRemoteEval();\n      return;\n    }\n    this._updateAllAutoExperiments();\n    this._render();\n  }\n  run(experiment) {\n    const result = this._run(experiment, null);\n    this._fireSubscriptions(experiment, result);\n    return result;\n  }\n  triggerExperiment(key) {\n    this._triggeredExpKeys.add(key);\n    if (!this._ctx.experiments) return null;\n    const experiments = this._ctx.experiments.filter(exp => exp.key === key);\n    return experiments.map(exp => {\n      return this._runAutoExperiment(exp);\n    }).filter(res => res !== null);\n  }\n  triggerAutoExperiments() {\n    this._autoExperimentsAllowed = true;\n    this._updateAllAutoExperiments(true);\n  }\n  _runAutoExperiment(experiment, forceRerun) {\n    const existing = this._activeAutoExperiments.get(experiment);\n\n    // If this is a manual experiment and it's not already running, skip\n    if (experiment.manual && !this._triggeredExpKeys.has(experiment.key) && !existing) return null;\n\n    // Check if this particular experiment is blocked by context settings\n    // For example, if all visualEditor experiments are disabled\n    const isBlocked = this._isAutoExperimentBlockedByContext(experiment);\n    if (isBlocked) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Auto experiment blocked\", {\n        id: experiment.key\n      });\n    }\n\n    // Run the experiment (if blocked exclude)\n    const result = isBlocked ? this._getResult(experiment, -1, false, \"\") : this.run(experiment);\n\n    // A hash to quickly tell if the assigned value changed\n    const valueHash = JSON.stringify(result.value);\n\n    // If the changes are already active, no need to re-apply them\n    if (!forceRerun && result.inExperiment && existing && existing.valueHash === valueHash) {\n      return result;\n    }\n\n    // Undo any existing changes\n    if (existing) this._undoActiveAutoExperiment(experiment);\n\n    // Apply new changes\n    if (result.inExperiment) {\n      const changeType = getAutoExperimentChangeType(experiment);\n      if (changeType === \"redirect\" && result.value.urlRedirect && experiment.urlPatterns) {\n        const url = experiment.persistQueryString ? mergeQueryStrings(this._getContextUrl(), result.value.urlRedirect) : result.value.urlRedirect;\n        if (isURLTargeted(url, experiment.urlPatterns)) {\n          this.log(\"Skipping redirect because original URL matches redirect URL\", {\n            id: experiment.key\n          });\n          return result;\n        }\n        this._redirectedUrl = url;\n        const navigate = this._getNavigateFunction();\n        if (navigate) {\n          if (isBrowser) {\n            var _this$_ctx$navigateDe;\n            this._setAntiFlicker();\n            window.setTimeout(() => {\n              try {\n                navigate(url);\n              } catch (e) {\n                console.error(e);\n              }\n            }, (_this$_ctx$navigateDe = this._ctx.navigateDelay) !== null && _this$_ctx$navigateDe !== void 0 ? _this$_ctx$navigateDe : 100);\n          } else {\n            try {\n              navigate(url);\n            } catch (e) {\n              console.error(e);\n            }\n          }\n        }\n      } else if (changeType === \"visual\") {\n        const undo = this._ctx.applyDomChangesCallback ? this._ctx.applyDomChangesCallback(result.value) : this._applyDOMChanges(result.value);\n        if (undo) {\n          this._activeAutoExperiments.set(experiment, {\n            undo,\n            valueHash\n          });\n        }\n      }\n    }\n    return result;\n  }\n  _undoActiveAutoExperiment(exp) {\n    const data = this._activeAutoExperiments.get(exp);\n    if (data) {\n      data.undo();\n      this._activeAutoExperiments.delete(exp);\n    }\n  }\n  _updateAllAutoExperiments(forceRerun) {\n    if (!this._autoExperimentsAllowed) return;\n    const experiments = this._ctx.experiments || [];\n\n    // Stop any experiments that are no longer defined\n    const keys = new Set(experiments);\n    this._activeAutoExperiments.forEach((v, k) => {\n      if (!keys.has(k)) {\n        v.undo();\n        this._activeAutoExperiments.delete(k);\n      }\n    });\n\n    // Re-run all new/updated experiments\n    for (const exp of experiments) {\n      const result = this._runAutoExperiment(exp, forceRerun);\n\n      // Once you're in a redirect experiment, break out of the loop and don't run any further experiments\n      if (result !== null && result !== void 0 && result.inExperiment && getAutoExperimentChangeType(exp) === \"redirect\") {\n        break;\n      }\n    }\n  }\n  _fireSubscriptions(experiment, result) {\n    const key = experiment.key;\n\n    // If assigned variation has changed, fire subscriptions\n    const prev = this._assigned.get(key);\n    // TODO: what if the experiment definition has changed?\n    if (!prev || prev.result.inExperiment !== result.inExperiment || prev.result.variationId !== result.variationId) {\n      this._assigned.set(key, {\n        experiment,\n        result\n      });\n      this._subscriptions.forEach(cb => {\n        try {\n          cb(experiment, result);\n        } catch (e) {\n          console.error(e);\n        }\n      });\n    }\n  }\n  _trackFeatureUsage(key, res) {\n    // Don't track feature usage that was forced via an override\n    if (res.source === \"override\") return;\n\n    // Only track a feature once, unless the assigned value changed\n    const stringifiedValue = JSON.stringify(res.value);\n    if (this._trackedFeatures[key] === stringifiedValue) return;\n    this._trackedFeatures[key] = stringifiedValue;\n\n    // Fire user-supplied callback\n    if (this._ctx.onFeatureUsage) {\n      try {\n        this._ctx.onFeatureUsage(key, res);\n      } catch (e) {\n        // Ignore feature usage callback errors\n      }\n    }\n\n    // In browser environments, queue up feature usage to be tracked in batches\n    if (!isBrowser || !window.fetch) return;\n    this._rtQueue.push({\n      key,\n      on: res.on\n    });\n    if (!this._rtTimer) {\n      this._rtTimer = window.setTimeout(() => {\n        // Reset the queue\n        this._rtTimer = 0;\n        const q = [...this._rtQueue];\n        this._rtQueue = [];\n\n        // Skip logging if a real-time usage key is not configured\n        if (!this._ctx.realtimeKey) return;\n        window.fetch(\"https://rt.growthbook.io/?key=\".concat(this._ctx.realtimeKey, \"&events=\").concat(encodeURIComponent(JSON.stringify(q))), {\n          cache: \"no-cache\",\n          mode: \"no-cors\"\n        }).catch(() => {\n          // TODO: retry in case of network errors?\n        });\n      }, this._ctx.realtimeInterval || 2000);\n    }\n  }\n  _getFeatureResult(key, value, source, ruleId, experiment, result) {\n    const ret = {\n      value,\n      on: !!value,\n      off: !value,\n      source,\n      ruleId: ruleId || \"\"\n    };\n    if (experiment) ret.experiment = experiment;\n    if (result) ret.experimentResult = result;\n\n    // Track the usage of this feature in real-time\n    this._trackFeatureUsage(key, ret);\n    return ret;\n  }\n  isOn(key) {\n    return this.evalFeature(key).on;\n  }\n  isOff(key) {\n    return this.evalFeature(key).off;\n  }\n  getFeatureValue(key, defaultValue) {\n    const value = this.evalFeature(key).value;\n    return value === null ? defaultValue : value;\n  }\n\n  /**\n   * @deprecated Use {@link evalFeature}\n   * @param id\n   */\n  // eslint-disable-next-line\n  feature(id) {\n    return this.evalFeature(id);\n  }\n  evalFeature(id) {\n    return this._evalFeature(id);\n  }\n  _evalFeature(id, evalCtx) {\n    evalCtx = evalCtx || {\n      evaluatedFeatures: new Set()\n    };\n    if (evalCtx.evaluatedFeatures.has(id)) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"evalFeature: circular dependency detected: \".concat(evalCtx.id, \" -> \").concat(id), {\n        from: evalCtx.id,\n        to: id\n      });\n      return this._getFeatureResult(id, null, \"cyclicPrerequisite\");\n    }\n    evalCtx.evaluatedFeatures.add(id);\n    evalCtx.id = id;\n\n    // Global override\n    if (this._forcedFeatureValues.has(id)) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Global override\", {\n        id,\n        value: this._forcedFeatureValues.get(id)\n      });\n      return this._getFeatureResult(id, this._forcedFeatureValues.get(id), \"override\");\n    }\n\n    // Unknown feature id\n    if (!this._ctx.features || !this._ctx.features[id]) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Unknown feature\", {\n        id\n      });\n      return this._getFeatureResult(id, null, \"unknownFeature\");\n    }\n\n    // Get the feature\n    const feature = this._ctx.features[id];\n\n    // Loop through the rules\n    if (feature.rules) {\n      rules: for (const rule of feature.rules) {\n        // If there are prerequisite flag(s), evaluate them\n        if (rule.parentConditions) {\n          for (const parentCondition of rule.parentConditions) {\n            const parentResult = this._evalFeature(parentCondition.id, evalCtx);\n            // break out for cyclic prerequisites\n            if (parentResult.source === \"cyclicPrerequisite\") {\n              return this._getFeatureResult(id, null, \"cyclicPrerequisite\");\n            }\n            const evalObj = {\n              value: parentResult.value\n            };\n            const evaled = evalCondition(evalObj, parentCondition.condition || {});\n            if (!evaled) {\n              // blocking prerequisite eval failed: feature evaluation fails\n              if (parentCondition.gate) {\n                process.env.NODE_ENV !== \"production\" && this.log(\"Feature blocked by prerequisite\", {\n                  id,\n                  rule\n                });\n                return this._getFeatureResult(id, null, \"prerequisite\");\n              }\n              // non-blocking prerequisite eval failed: break out of parentConditions loop, jump to the next rule\n              process.env.NODE_ENV !== \"production\" && this.log(\"Skip rule because prerequisite evaluation fails\", {\n                id,\n                rule\n              });\n              continue rules;\n            }\n          }\n        }\n\n        // If there are filters for who is included (e.g. namespaces)\n        if (rule.filters && this._isFilteredOut(rule.filters)) {\n          process.env.NODE_ENV !== \"production\" && this.log(\"Skip rule because of filters\", {\n            id,\n            rule\n          });\n          continue;\n        }\n\n        // Feature value is being forced\n        if (\"force\" in rule) {\n          // If it's a conditional rule, skip if the condition doesn't pass\n          if (rule.condition && !this._conditionPasses(rule.condition)) {\n            process.env.NODE_ENV !== \"production\" && this.log(\"Skip rule because of condition ff\", {\n              id,\n              rule\n            });\n            continue;\n          }\n\n          // If this is a percentage rollout, skip if not included\n          if (!this._isIncludedInRollout(rule.seed || id, rule.hashAttribute, this._ctx.stickyBucketService && !rule.disableStickyBucketing ? rule.fallbackAttribute : undefined, rule.range, rule.coverage, rule.hashVersion)) {\n            process.env.NODE_ENV !== \"production\" && this.log(\"Skip rule because user not included in rollout\", {\n              id,\n              rule\n            });\n            continue;\n          }\n          process.env.NODE_ENV !== \"production\" && this.log(\"Force value from rule\", {\n            id,\n            rule\n          });\n\n          // If this was a remotely evaluated experiment, fire the tracking callbacks\n          if (rule.tracks) {\n            rule.tracks.forEach(t => {\n              this._track(t.experiment, t.result);\n            });\n          }\n          return this._getFeatureResult(id, rule.force, \"force\", rule.id);\n        }\n        if (!rule.variations) {\n          process.env.NODE_ENV !== \"production\" && this.log(\"Skip invalid rule\", {\n            id,\n            rule\n          });\n          continue;\n        }\n\n        // For experiment rules, run an experiment\n        const exp = {\n          variations: rule.variations,\n          key: rule.key || id\n        };\n        if (\"coverage\" in rule) exp.coverage = rule.coverage;\n        if (rule.weights) exp.weights = rule.weights;\n        if (rule.hashAttribute) exp.hashAttribute = rule.hashAttribute;\n        if (rule.fallbackAttribute) exp.fallbackAttribute = rule.fallbackAttribute;\n        if (rule.disableStickyBucketing) exp.disableStickyBucketing = rule.disableStickyBucketing;\n        if (rule.bucketVersion !== undefined) exp.bucketVersion = rule.bucketVersion;\n        if (rule.minBucketVersion !== undefined) exp.minBucketVersion = rule.minBucketVersion;\n        if (rule.namespace) exp.namespace = rule.namespace;\n        if (rule.meta) exp.meta = rule.meta;\n        if (rule.ranges) exp.ranges = rule.ranges;\n        if (rule.name) exp.name = rule.name;\n        if (rule.phase) exp.phase = rule.phase;\n        if (rule.seed) exp.seed = rule.seed;\n        if (rule.hashVersion) exp.hashVersion = rule.hashVersion;\n        if (rule.filters) exp.filters = rule.filters;\n        if (rule.condition) exp.condition = rule.condition;\n\n        // Only return a value if the user is part of the experiment\n        const res = this._run(exp, id);\n        this._fireSubscriptions(exp, res);\n        if (res.inExperiment && !res.passthrough) {\n          return this._getFeatureResult(id, res.value, \"experiment\", rule.id, exp, res);\n        }\n      }\n    }\n    process.env.NODE_ENV !== \"production\" && this.log(\"Use default value\", {\n      id,\n      value: feature.defaultValue\n    });\n\n    // Fall back to using the default value\n    return this._getFeatureResult(id, feature.defaultValue === undefined ? null : feature.defaultValue, \"defaultValue\");\n  }\n  _isIncludedInRollout(seed, hashAttribute, fallbackAttribute, range, coverage, hashVersion) {\n    if (!range && coverage === undefined) return true;\n    if (!range && coverage === 0) return false;\n    const {\n      hashValue\n    } = this._getHashAttribute(hashAttribute, fallbackAttribute);\n    if (!hashValue) {\n      return false;\n    }\n    const n = hash(seed, hashValue, hashVersion || 1);\n    if (n === null) return false;\n    return range ? inRange(n, range) : coverage !== undefined ? n <= coverage : true;\n  }\n  _conditionPasses(condition) {\n    return evalCondition(this.getAttributes(), condition, this._ctx.savedGroups || {});\n  }\n  _isFilteredOut(filters) {\n    return filters.some(filter => {\n      const {\n        hashValue\n      } = this._getHashAttribute(filter.attribute);\n      if (!hashValue) return true;\n      const n = hash(filter.seed, hashValue, filter.hashVersion || 2);\n      if (n === null) return true;\n      return !filter.ranges.some(r => inRange(n, r));\n    });\n  }\n  _run(experiment, featureId) {\n    const key = experiment.key;\n    const numVariations = experiment.variations.length;\n\n    // 1. If experiment has less than 2 variations, return immediately\n    if (numVariations < 2) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Invalid experiment\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 2. If the context is disabled, return immediately\n    if (this._ctx.enabled === false) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Context disabled\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 2.5. Merge in experiment overrides from the context\n    experiment = this._mergeOverrides(experiment);\n\n    // 2.6 New, more powerful URL targeting\n    if (experiment.urlPatterns && !isURLTargeted(this._getContextUrl(), experiment.urlPatterns)) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of url targeting\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 3. If a variation is forced from a querystring, return the forced variation\n    const qsOverride = getQueryStringOverride(key, this._getContextUrl(), numVariations);\n    if (qsOverride !== null) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Force via querystring\", {\n        id: key,\n        variation: qsOverride\n      });\n      return this._getResult(experiment, qsOverride, false, featureId);\n    }\n\n    // 4. If a variation is forced in the context, return the forced variation\n    if (this._ctx.forcedVariations && key in this._ctx.forcedVariations) {\n      const variation = this._ctx.forcedVariations[key];\n      process.env.NODE_ENV !== \"production\" && this.log(\"Force via dev tools\", {\n        id: key,\n        variation\n      });\n      return this._getResult(experiment, variation, false, featureId);\n    }\n\n    // 5. Exclude if a draft experiment or not active\n    if (experiment.status === \"draft\" || experiment.active === false) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because inactive\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 6. Get the hash attribute and return if empty\n    const {\n      hashAttribute,\n      hashValue\n    } = this._getHashAttribute(experiment.hashAttribute, this._ctx.stickyBucketService && !experiment.disableStickyBucketing ? experiment.fallbackAttribute : undefined);\n    if (!hashValue) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because missing hashAttribute\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n    let assigned = -1;\n    let foundStickyBucket = false;\n    let stickyBucketVersionIsBlocked = false;\n    if (this._ctx.stickyBucketService && !experiment.disableStickyBucketing) {\n      const {\n        variation,\n        versionIsBlocked\n      } = this._getStickyBucketVariation({\n        expKey: experiment.key,\n        expBucketVersion: experiment.bucketVersion,\n        expHashAttribute: experiment.hashAttribute,\n        expFallbackAttribute: experiment.fallbackAttribute,\n        expMinBucketVersion: experiment.minBucketVersion,\n        expMeta: experiment.meta\n      });\n      foundStickyBucket = variation >= 0;\n      assigned = variation;\n      stickyBucketVersionIsBlocked = !!versionIsBlocked;\n    }\n\n    // Some checks are not needed if we already have a sticky bucket\n    if (!foundStickyBucket) {\n      // 7. Exclude if user is filtered out (used to be called \"namespace\")\n      if (experiment.filters) {\n        if (this._isFilteredOut(experiment.filters)) {\n          process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of filters\", {\n            id: key\n          });\n          return this._getResult(experiment, -1, false, featureId);\n        }\n      } else if (experiment.namespace && !inNamespace(hashValue, experiment.namespace)) {\n        process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of namespace\", {\n          id: key\n        });\n        return this._getResult(experiment, -1, false, featureId);\n      }\n\n      // 7.5. Exclude if experiment.include returns false or throws\n      if (experiment.include && !isIncluded(experiment.include)) {\n        process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of include function\", {\n          id: key\n        });\n        return this._getResult(experiment, -1, false, featureId);\n      }\n\n      // 8. Exclude if condition is false\n      if (experiment.condition && !this._conditionPasses(experiment.condition)) {\n        process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of condition exp\", {\n          id: key\n        });\n        return this._getResult(experiment, -1, false, featureId);\n      }\n\n      // 8.05. Exclude if prerequisites are not met\n      if (experiment.parentConditions) {\n        for (const parentCondition of experiment.parentConditions) {\n          const parentResult = this._evalFeature(parentCondition.id);\n          // break out for cyclic prerequisites\n          if (parentResult.source === \"cyclicPrerequisite\") {\n            return this._getResult(experiment, -1, false, featureId);\n          }\n          const evalObj = {\n            value: parentResult.value\n          };\n          if (!evalCondition(evalObj, parentCondition.condition || {})) {\n            process.env.NODE_ENV !== \"production\" && this.log(\"Skip because prerequisite evaluation fails\", {\n              id: key\n            });\n            return this._getResult(experiment, -1, false, featureId);\n          }\n        }\n      }\n\n      // 8.1. Exclude if user is not in a required group\n      if (experiment.groups && !this._hasGroupOverlap(experiment.groups)) {\n        process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of groups\", {\n          id: key\n        });\n        return this._getResult(experiment, -1, false, featureId);\n      }\n    }\n\n    // 8.2. Old style URL targeting\n    if (experiment.url && !this._urlIsValid(experiment.url)) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of url\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 9. Get the variation from the sticky bucket or get bucket ranges and choose variation\n    const n = hash(experiment.seed || key, hashValue, experiment.hashVersion || 1);\n    if (n === null) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of invalid hash version\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n    if (!foundStickyBucket) {\n      const ranges = experiment.ranges || getBucketRanges(numVariations, experiment.coverage === undefined ? 1 : experiment.coverage, experiment.weights);\n      assigned = chooseVariation(n, ranges);\n    }\n\n    // 9.5 Unenroll if any prior sticky buckets are blocked by version\n    if (stickyBucketVersionIsBlocked) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because sticky bucket version is blocked\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId, undefined, true);\n    }\n\n    // 10. Return if not in experiment\n    if (assigned < 0) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because of coverage\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 11. Experiment has a forced variation\n    if (\"force\" in experiment) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Force variation\", {\n        id: key,\n        variation: experiment.force\n      });\n      return this._getResult(experiment, experiment.force === undefined ? -1 : experiment.force, false, featureId);\n    }\n\n    // 12. Exclude if in QA mode\n    if (this._ctx.qaMode) {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because QA mode\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 12.5. Exclude if experiment is stopped\n    if (experiment.status === \"stopped\") {\n      process.env.NODE_ENV !== \"production\" && this.log(\"Skip because stopped\", {\n        id: key\n      });\n      return this._getResult(experiment, -1, false, featureId);\n    }\n\n    // 13. Build the result object\n    const result = this._getResult(experiment, assigned, true, featureId, n, foundStickyBucket);\n\n    // 13.5. Persist sticky bucket\n    if (this._ctx.stickyBucketService && !experiment.disableStickyBucketing) {\n      const {\n        changed,\n        key: attrKey,\n        doc\n      } = this._generateStickyBucketAssignmentDoc(hashAttribute, toString(hashValue), {\n        [this._getStickyBucketExperimentKey(experiment.key, experiment.bucketVersion)]: result.key\n      });\n      if (changed) {\n        // update local docs\n        this._ctx.stickyBucketAssignmentDocs = this._ctx.stickyBucketAssignmentDocs || {};\n        this._ctx.stickyBucketAssignmentDocs[attrKey] = doc;\n        // save doc\n        this._ctx.stickyBucketService.saveAssignments(doc);\n      }\n    }\n\n    // 14. Fire the tracking callback\n    this._track(experiment, result);\n\n    // 14.1 Keep track of completed changeIds\n    \"changeId\" in experiment && experiment.changeId && this._completedChangeIds.add(experiment.changeId);\n\n    // 15. Return the result\n    process.env.NODE_ENV !== \"production\" && this.log(\"In experiment\", {\n      id: key,\n      variation: result.variationId\n    });\n    return result;\n  }\n  log(msg, ctx) {\n    if (!this.debug) return;\n    if (this._ctx.log) this._ctx.log(msg, ctx);else console.log(msg, ctx);\n  }\n  getDeferredTrackingCalls() {\n    return Array.from(this._deferredTrackingCalls.values());\n  }\n  setDeferredTrackingCalls(calls) {\n    this._deferredTrackingCalls = new Map(calls.filter(c => c && c.experiment && c.result).map(c => {\n      return [this._getTrackKey(c.experiment, c.result), c];\n    }));\n  }\n  fireDeferredTrackingCalls() {\n    if (!this._ctx.trackingCallback) return;\n    this._deferredTrackingCalls.forEach(call => {\n      if (!call || !call.experiment || !call.result) {\n        console.error(\"Invalid deferred tracking call\", {\n          call: call\n        });\n      } else {\n        this._track(call.experiment, call.result);\n      }\n    });\n    this._deferredTrackingCalls.clear();\n  }\n  setTrackingCallback(callback) {\n    this._ctx.trackingCallback = callback;\n    this.fireDeferredTrackingCalls();\n  }\n  _getTrackKey(experiment, result) {\n    return result.hashAttribute + result.hashValue + experiment.key + result.variationId;\n  }\n  _track(experiment, result) {\n    const k = this._getTrackKey(experiment, result);\n    if (!this._ctx.trackingCallback) {\n      // Add to deferred tracking if it hasn't already been added\n      if (!this._deferredTrackingCalls.has(k)) {\n        this._deferredTrackingCalls.set(k, {\n          experiment,\n          result\n        });\n      }\n      return;\n    }\n\n    // Make sure a tracking callback is only fired once per unique experiment\n    if (this._trackedExperiments.has(k)) return;\n    this._trackedExperiments.add(k);\n    try {\n      this._ctx.trackingCallback(experiment, result);\n    } catch (e) {\n      console.error(e);\n    }\n  }\n  _mergeOverrides(experiment) {\n    const key = experiment.key;\n    const o = this._ctx.overrides;\n    if (o && o[key]) {\n      experiment = Object.assign({}, experiment, o[key]);\n      if (typeof experiment.url === \"string\") {\n        experiment.url = getUrlRegExp(\n        // eslint-disable-next-line\n        experiment.url);\n      }\n    }\n    return experiment;\n  }\n  _getHashAttribute(attr, fallback) {\n    let hashAttribute = attr || \"id\";\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let hashValue = \"\";\n    if (this._attributeOverrides[hashAttribute]) {\n      hashValue = this._attributeOverrides[hashAttribute];\n    } else if (this._ctx.attributes) {\n      hashValue = this._ctx.attributes[hashAttribute] || \"\";\n    } else if (this._ctx.user) {\n      hashValue = this._ctx.user[hashAttribute] || \"\";\n    }\n\n    // if no match, try fallback\n    if (!hashValue && fallback) {\n      if (this._attributeOverrides[fallback]) {\n        hashValue = this._attributeOverrides[fallback];\n      } else if (this._ctx.attributes) {\n        hashValue = this._ctx.attributes[fallback] || \"\";\n      } else if (this._ctx.user) {\n        hashValue = this._ctx.user[fallback] || \"\";\n      }\n      if (hashValue) {\n        hashAttribute = fallback;\n      }\n    }\n    return {\n      hashAttribute,\n      hashValue\n    };\n  }\n  _getResult(experiment, variationIndex, hashUsed, featureId, bucket, stickyBucketUsed) {\n    let inExperiment = true;\n    // If assigned variation is not valid, use the baseline and mark the user as not in the experiment\n    if (variationIndex < 0 || variationIndex >= experiment.variations.length) {\n      variationIndex = 0;\n      inExperiment = false;\n    }\n    const {\n      hashAttribute,\n      hashValue\n    } = this._getHashAttribute(experiment.hashAttribute, this._ctx.stickyBucketService && !experiment.disableStickyBucketing ? experiment.fallbackAttribute : undefined);\n    const meta = experiment.meta ? experiment.meta[variationIndex] : {};\n    const res = {\n      key: meta.key || \"\" + variationIndex,\n      featureId,\n      inExperiment,\n      hashUsed,\n      variationId: variationIndex,\n      value: experiment.variations[variationIndex],\n      hashAttribute,\n      hashValue,\n      stickyBucketUsed: !!stickyBucketUsed\n    };\n    if (meta.name) res.name = meta.name;\n    if (bucket !== undefined) res.bucket = bucket;\n    if (meta.passthrough) res.passthrough = meta.passthrough;\n    return res;\n  }\n  _getContextUrl() {\n    return this._ctx.url || (isBrowser ? window.location.href : \"\");\n  }\n  _urlIsValid(urlRegex) {\n    const url = this._getContextUrl();\n    if (!url) return false;\n    const pathOnly = url.replace(/^https?:\\/\\//, \"\").replace(/^[^/]*\\//, \"/\");\n    if (urlRegex.test(url)) return true;\n    if (urlRegex.test(pathOnly)) return true;\n    return false;\n  }\n  _hasGroupOverlap(expGroups) {\n    const groups = this._ctx.groups || {};\n    for (let i = 0; i < expGroups.length; i++) {\n      if (groups[expGroups[i]]) return true;\n    }\n    return false;\n  }\n  _isAutoExperimentBlockedByContext(experiment) {\n    const changeType = getAutoExperimentChangeType(experiment);\n    if (changeType === \"visual\") {\n      if (this._ctx.disableVisualExperiments) return true;\n      if (this._ctx.disableJsInjection) {\n        if (experiment.variations.some(v => v.js)) {\n          return true;\n        }\n      }\n    } else if (changeType === \"redirect\") {\n      if (this._ctx.disableUrlRedirectExperiments) return true;\n\n      // Validate URLs\n      try {\n        const current = new URL(this._getContextUrl());\n        for (const v of experiment.variations) {\n          if (!v || !v.urlRedirect) continue;\n          const url = new URL(v.urlRedirect);\n\n          // If we're blocking cross origin redirects, block if the protocol or host is different\n          if (this._ctx.disableCrossOriginUrlRedirectExperiments) {\n            if (url.protocol !== current.protocol) return true;\n            if (url.host !== current.host) return true;\n          }\n        }\n      } catch (e) {\n        // Problem parsing one of the URLs\n        this.log(\"Error parsing current or redirect URL\", {\n          id: experiment.key,\n          error: e\n        });\n        return true;\n      }\n    } else {\n      // Block any unknown changeTypes\n      return true;\n    }\n    if (experiment.changeId && (this._ctx.blockedChangeIds || []).includes(experiment.changeId)) {\n      return true;\n    }\n    return false;\n  }\n  getRedirectUrl() {\n    return this._redirectedUrl;\n  }\n  _getNavigateFunction() {\n    if (this._ctx.navigate) {\n      return this._ctx.navigate;\n    } else if (isBrowser) {\n      return url => {\n        window.location.replace(url);\n      };\n    }\n    return null;\n  }\n  _setAntiFlicker() {\n    if (!this._ctx.antiFlicker || !isBrowser) return;\n    try {\n      var _this$_ctx$antiFlicke;\n      const styleTag = document.createElement(\"style\");\n      styleTag.innerHTML = \".gb-anti-flicker { opacity: 0 !important; pointer-events: none; }\";\n      document.head.appendChild(styleTag);\n      document.documentElement.classList.add(\"gb-anti-flicker\");\n\n      // Fallback if GrowthBook fails to load in specified time or 3.5 seconds\n      setTimeout(() => {\n        document.documentElement.classList.remove(\"gb-anti-flicker\");\n      }, (_this$_ctx$antiFlicke = this._ctx.antiFlickerTimeout) !== null && _this$_ctx$antiFlicke !== void 0 ? _this$_ctx$antiFlicke : 3500);\n    } catch (e) {\n      console.error(e);\n    }\n  }\n  _applyDOMChanges(changes) {\n    if (!isBrowser) return;\n    const undo = [];\n    if (changes.css) {\n      const s = document.createElement(\"style\");\n      s.innerHTML = changes.css;\n      document.head.appendChild(s);\n      undo.push(() => s.remove());\n    }\n    if (changes.js) {\n      const script = document.createElement(\"script\");\n      script.innerHTML = changes.js;\n      if (this._ctx.jsInjectionNonce) {\n        script.nonce = this._ctx.jsInjectionNonce;\n      }\n      document.head.appendChild(script);\n      undo.push(() => script.remove());\n    }\n    if (changes.domMutations) {\n      changes.domMutations.forEach(mutation => {\n        undo.push(mutate.declarative(mutation).revert);\n      });\n    }\n    return () => {\n      undo.forEach(fn => fn());\n    };\n  }\n  _deriveStickyBucketIdentifierAttributes(data) {\n    const attributes = new Set();\n    const features = data && data.features ? data.features : this.getFeatures();\n    const experiments = data && data.experiments ? data.experiments : this.getExperiments();\n    Object.keys(features).forEach(id => {\n      const feature = features[id];\n      if (feature.rules) {\n        for (const rule of feature.rules) {\n          if (rule.variations) {\n            attributes.add(rule.hashAttribute || \"id\");\n            if (rule.fallbackAttribute) {\n              attributes.add(rule.fallbackAttribute);\n            }\n          }\n        }\n      }\n    });\n    experiments.map(experiment => {\n      attributes.add(experiment.hashAttribute || \"id\");\n      if (experiment.fallbackAttribute) {\n        attributes.add(experiment.fallbackAttribute);\n      }\n    });\n    return Array.from(attributes);\n  }\n  async refreshStickyBuckets(data) {\n    if (this._ctx.stickyBucketService) {\n      const attributes = this._getStickyBucketAttributes(data);\n      this._ctx.stickyBucketAssignmentDocs = await this._ctx.stickyBucketService.getAllAssignments(attributes);\n    }\n  }\n  _getStickyBucketAssignments(expHashAttribute, expFallbackAttribute) {\n    if (!this._ctx.stickyBucketAssignmentDocs) return {};\n    const {\n      hashAttribute,\n      hashValue\n    } = this._getHashAttribute(expHashAttribute);\n    const hashKey = \"\".concat(hashAttribute, \"||\").concat(toString(hashValue));\n    const {\n      hashAttribute: fallbackAttribute,\n      hashValue: fallbackValue\n    } = this._getHashAttribute(expFallbackAttribute);\n    const fallbackKey = fallbackValue ? \"\".concat(fallbackAttribute, \"||\").concat(toString(fallbackValue)) : null;\n    const assignments = {};\n    if (fallbackKey && this._ctx.stickyBucketAssignmentDocs[fallbackKey]) {\n      Object.assign(assignments, this._ctx.stickyBucketAssignmentDocs[fallbackKey].assignments || {});\n    }\n    if (this._ctx.stickyBucketAssignmentDocs[hashKey]) {\n      Object.assign(assignments, this._ctx.stickyBucketAssignmentDocs[hashKey].assignments || {});\n    }\n    return assignments;\n  }\n  _getStickyBucketVariation(_ref3) {\n    let {\n      expKey,\n      expBucketVersion,\n      expHashAttribute,\n      expFallbackAttribute,\n      expMinBucketVersion,\n      expMeta\n    } = _ref3;\n    expBucketVersion = expBucketVersion || 0;\n    expMinBucketVersion = expMinBucketVersion || 0;\n    expHashAttribute = expHashAttribute || \"id\";\n    expMeta = expMeta || [];\n    const id = this._getStickyBucketExperimentKey(expKey, expBucketVersion);\n    const assignments = this._getStickyBucketAssignments(expHashAttribute, expFallbackAttribute);\n\n    // users with any blocked bucket version (0 to minExperimentBucketVersion) are excluded from the test\n    if (expMinBucketVersion > 0) {\n      for (let i = 0; i <= expMinBucketVersion; i++) {\n        const blockedKey = this._getStickyBucketExperimentKey(expKey, i);\n        if (assignments[blockedKey] !== undefined) {\n          return {\n            variation: -1,\n            versionIsBlocked: true\n          };\n        }\n      }\n    }\n    const variationKey = assignments[id];\n    if (variationKey === undefined)\n      // no assignment found\n      return {\n        variation: -1\n      };\n    const variation = expMeta.findIndex(m => m.key === variationKey);\n    if (variation < 0)\n      // invalid assignment, treat as \"no assignment found\"\n      return {\n        variation: -1\n      };\n    return {\n      variation\n    };\n  }\n  _getStickyBucketExperimentKey(experimentKey, experimentBucketVersion) {\n    experimentBucketVersion = experimentBucketVersion || 0;\n    return \"\".concat(experimentKey, \"__\").concat(experimentBucketVersion);\n  }\n  _getStickyBucketAttributes(data) {\n    const attributes = {};\n    this._ctx.stickyBucketIdentifierAttributes = !this._ctx.stickyBucketIdentifierAttributes ? this._deriveStickyBucketIdentifierAttributes(data) : this._ctx.stickyBucketIdentifierAttributes;\n    this._ctx.stickyBucketIdentifierAttributes.forEach(attr => {\n      const {\n        hashValue\n      } = this._getHashAttribute(attr);\n      attributes[attr] = toString(hashValue);\n    });\n    return attributes;\n  }\n  _generateStickyBucketAssignmentDoc(attributeName, attributeValue, assignments) {\n    const key = \"\".concat(attributeName, \"||\").concat(attributeValue);\n    const existingAssignments = this._ctx.stickyBucketAssignmentDocs && this._ctx.stickyBucketAssignmentDocs[key] ? this._ctx.stickyBucketAssignmentDocs[key].assignments || {} : {};\n    const newAssignments = {\n      ...existingAssignments,\n      ...assignments\n    };\n    const changed = JSON.stringify(existingAssignments) !== JSON.stringify(newAssignments);\n    return {\n      key,\n      doc: {\n        attributeName,\n        attributeValue,\n        assignments: newAssignments\n      },\n      changed\n    };\n  }\n}\nexport async function prefetchPayload(options) {\n  // Create a temporary instance, just to fetch the payload\n  const instance = new GrowthBook(options);\n  await refreshFeatures({\n    instance,\n    skipCache: options.skipCache,\n    allowStale: false,\n    backgroundSync: options.streaming\n  });\n  instance.destroy();\n}\n//# sourceMappingURL=GrowthBook.mjs.map","import { GrowthBook } from '@growthbook/growthbook';\n\nexport interface FeatureI {\n    active?: false; //default feature values, we only use the targeted ones\n    start_date: string;\n    start_time: string;\n    end_date: string;\n    end_time: string;\n    position: string;\n    template: Template;\n}\n\ninterface PageType {\n    type: string;\n    match: string;\n    post_type: any[];\n    post_premium: boolean;\n}\n\ninterface Template {\n    [key: string]: string;\n}\n\nfunction log(...a: any[]) {\n    if (location.search.includes('gb_debug')) {\n        console.log(...a);\n    }\n}\nexport class GrowthbookManager {\n    private static readonly mainFolder = '\\\\wp-content\\\\themes\\\\observador-child\\\\Features\\\\Growthbook\\\\';\n    private static readonly buildFolder = this.mainFolder + 'build\\\\';\n    private static readonly cssBuild = this.buildFolder + 'css\\\\';\n    private static readonly jsBuild = this.buildFolder + 'js\\\\';\n    private static readonly templates = this.mainFolder + 'components\\\\html\\\\';\n\n    private static _instance: GrowthBook;\n    private static initStatus: {\n        success: boolean;\n        source: string;\n    };\n\n    public static getInitStatus() {\n        return GrowthbookManager.initStatus;\n    }\n\n    static isFeatureActive(f: FeatureI) {\n        if (!f || f.active === false) {\n            return false;\n        }\n\n        const startDate = new Date(`${f.start_date} ${f.start_time}`);\n        const endDate = new Date(`${f.end_date} ${f.end_time}`);\n        const now = new Date();\n        return !(startDate.getTime() > now.getTime() || endDate.getTime() < now.getTime());\n    }\n    static handleTemplateFeature(f: FeatureI) {\n        if (!GrowthbookManager.isFeatureActive(f)) {\n            return;\n        }\n\n        const templateContainer = document.querySelector(f.position);\n        if (!templateContainer) {\n            return;\n        }\n\n        const css = document.createElement('link');\n        css.rel = 'stylesheet';\n        css.href = `${GrowthbookManager.cssBuild}${f.template.file}.min.css?obs_version=${contextualData.assetsVersion}`;\n\n        const js = document.createElement('script');\n        js.type = 'text/javascript';\n        js.src = `${GrowthbookManager.jsBuild}\\\\${f.template.file}.min.js?obs_version=${contextualData.assetsVersion}`;\n\n        document.body.appendChild(css);\n        document.body.appendChild(js);\n        fetch(`${GrowthbookManager.templates}${f.template.file}.html?obs_version=${contextualData.assetsVersion}`).then(async res => {\n            const htmlText = await res.text();\n            const element = document.createElement('div');\n            element.innerHTML = htmlText;\n\n            const el = element.firstChild;\n            //set all properties for the web component\n            for (const p in f.template) {\n                el[p] = f.template[p];\n            }\n\n            templateContainer.appendChild(el);\n        });\n    }\n\n    public static async getInstance() {\n        if (GrowthbookManager._instance) {\n            return GrowthbookManager._instance;\n        }\n        GrowthbookManager._instance = new GrowthBook({\n            apiHost: 'https://growthbook-api.observador.pt',\n            clientKey: contextualData.GROWTHBOOK_KEY,\n            enableDevMode: true,\n            trackingCallback: (experiment, result) => {\n                log('@@@Tracking', experiment, result);\n                dataLayer.push({\n                    event: 'gb_experiment_exposure',\n                    experiment_id: experiment.key,\n                    variation_id: result.key,\n                });\n            },\n            onFeatureUsage(key, res) {\n                log('@@@FeatureUsage', key, res);\n                //TODO if json feature type\n                if (res.value.template) {\n                    GrowthbookManager.handleTemplateFeature(res.value);\n                }\n            },\n        });\n\n        const us = adamastor.getSubscriptionSettings();\n\n        await GrowthbookManager._instance.setAttributes({\n            user_browser_id: localStorage.getItem('qrbid') ?? '',\n            url: window.location.pathname,\n            logged_in: adamastor.isLoggedIn(),\n            subscriber: adamastor.isSubscriber(),\n            subscriptions_plans: adamastor.getSubscriptionsProductsIds(),\n            engagement: GrowthbookManager.getUserEngagement(),\n            zone_type: contextualData.pageTargeting?.zoneType,\n            sub_zone_type: contextualData.pageTargeting?.subZoneType,\n            post_type: contextualData?.pageTargeting?.postType,\n            post_is_exclusive: contextualData?.pageTargeting?.exclusive,\n            top_category: contextualData?.pageTargeting?.topCategory,\n            category: contextualData?.pageTargeting?.category,\n            device_category: GrowthbookManager.getDeviceCategory(),\n            can_be_metered: GrowthbookManager.canBeMetered(),\n            page_slug: contextualData?.pageTargeting?.pageSlug,\n            id: adamastor?.getSessionProfile()?.sub ?? localStorage.getItem('qrbid') ?? '',\n            can_comment: us.canComment,\n            exclusive_articles: us.exclusiveArticles,\n            exclusive_newsletters: us.exclusiveNewsletters,\n            exclusive_opinion: us.exclusiveOpinion,\n            exclusive_podcasts: us.exclusivePodcasts,\n            less_pub: us.lessPub,\n            max_offer_articles: us.maxOfferArticles,\n            remove_pub: us.removePub,\n            subscription_source: adamastor.getSessionProfile()?.subscription?.products?.[0]?.source ?? null,\n            google_subscription_linked: adamastor.getSessionProfile()?.metadata?.find(item => item.name === 'subscriptionLinkingResult')?.value === \"true\",\n            google_subscription_linked_show_date: Number(adamastor.getSessionProfile()?.metadata?.find(item => item.name === 'subscriptionLinkingDate')?.value) ?? null\n        });\n\n        GrowthbookManager.initStatus = await GrowthbookManager._instance.init();\n\n        if (!GrowthbookManager.initStatus.success) {\n            dataLayer.push({\n                event: 'gb_init_error',\n            });\n        }\n\n        return GrowthbookManager._instance;\n    }\n\n    static getUserEngagement() {\n        const sum = articlesCounter.sum(4);\n        if (sum <= 2) return 'user-engagement-low';\n        if (sum >= 3 && sum <= 10) return 'user-engagement-medium';\n        if (sum >= 11) return 'user-engagement-high';\n    }\n\n    static canBeMetered() {\n        if (!contextualData.post) {\n            return false;\n        }\n\n        if (document.body.classList.contains('force-no-premium')) {\n            return false;\n        }\n\n        if (contextualData.post.isAnInitiative == true) {\n            return false;\n        }\n\n        if (contextualData.post.iniativeMediaPartner == true) {\n            return false;\n        }\n\n        const credits = contextualData.post.credits;\n\n        if (credits.find(c => c.creditAuthorName === 'obslab') !== undefined) {\n            return false;\n        }\n\n        switch (contextualData.post.postType) {\n            case 'obs_opinion':\n                return true;\n            case 'obs_episode':\n            case 'obs_bet':\n            case 'obs_bet_brazil':\n            case 'obs_liveblog':\n            case 'obs_interactive':\n                return false;\n            default:\n                if (credits.find(c => c.creditAuthorName === 'lusa') !== undefined) {\n                    return false;\n                }\n\n                /**\n                 * @type {Array}\n                 */\n                const categories = contextualData.post.categories;\n                if (categories.find(c => c === 'auto' || c === 'desporto' || c === 'lifestyle') !== undefined) {\n                    return false;\n                }\n\n                return true;\n        }\n    }\n\n    static getDeviceCategory() {\n        if (window.innerWidth < 768) return 'mobile';\n        if (window.innerWidth >= 768 && window.innerWidth < 1024) return 'tablet';\n        if (window.innerWidth >= 1024) return 'desktop';\n    }\n}\n\n/**\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#sect3\n * */\ndocument.addEventListener('obsLoginCallback', async function initGrowthBook() {\n    const gb = await GrowthbookManager.getInstance();\n    // TODO Move the paywall responsability to the paywall component\n    const features = gb.getFeatures();\n    for (const f in features) {\n        const fa = gb.evalFeature(f);\n        if (f.includes('app')) {\n            continue;\n        }\n\n        if (f.includes('paywall') && GrowthbookManager.isFeatureActive(fa.value)) {\n            window.obs_tp.paywallTriggered = true;\n        }\n        if (f === 'paywall-metered' && GrowthbookManager.isFeatureActive(fa.value)) {\n            window.obs_tp.paywallMetered = true;\n        }\n    }\n    obs_ads.trigger('paywall');\n});\n"],"names":["validAttributeName","nullController","revert","Map","mutations","Set","getElementRecord","element","record","get","attributes","set","createElementPropertyRecord","el","attr","getCurrentValue","setValue","mutationRunner","currentValue","isDirty","originalValue","virtualValue","_positionTimeout","observer","MutationObserver","setTimeout","parentNode","insertBeforeNode","observe","childList","subtree","characterData","attributeFilter","getObserverInit","queueIfNeeded","val","currentVal","runDOMUpdates","htmlMutationRunner","forEach","m","mutate","html","transformContainer","document","createElement","innerHTML","getTransformedHTML","classMutationRunner","split","filter","Boolean","Array","from","join","attrMutationRunner","positionMutationRunner","newNodes","_ref","parentSelector","insertBeforeSelector","querySelector","_loadDOMNodes","getHTMLValue","setHTMLValue","value","getElementHTMLRecord","elementRecord","getElementPosition","parentElement","nextElementSibling","setElementPosition","contains","insertBefore","getElementPositionRecord","position","setClassValue","className","removeAttribute","getClassValue","getElementClassRecord","classes","getAttrValue","attrName","_el$getAttribute","getAttribute","setAttrValue","setAttribute","getElementAttributeRecord","setPropertyValue","length","_element$html","_element$html$observe","disconnect","_element$classes","_element$classes$obse","_element$position","_element$position$obs","_element$attributes","_element$attributes$a","_element$attributes$a2","deleteElementPropertyRecord","Object","keys","refreshElementsSet","mutation","kind","elements","size","existingElements","querySelectorAll","selector","has","add","attribute","push","startMutating","refreshAllElementSets","newMutation","index","indexOf","splice","stopMutating","clear","test","classnames","mutatedClassnames","c","documentElement","_ref2","action","polyfills","fetch","globalThis","bind","undefined","SubtleCrypto","crypto","subtle","EventSource","hashFnv32a","str","hval","l","i","charCodeAt","hash","seed","version","inRange","n","range","getUrlRegExp","regexString","escaped","replace","RegExp","e","console","error","isURLTargeted","url","targets","hasIncludeRules","isIncluded","match","_evalURLTarget","type","pattern","include","parsed","URL","regex","href","substring","origin","actual","expected","comps","host","pathname","searchParams","v","k","some","data","isPath","_evalSimpleUrlPart","_evalSimpleUrlTarget","base64ToBuf","b","Uint8Array","atob","async","decrypt","encryptedString","decryptionKey","Error","key","importKey","name","iv","cipherText","plainTextBuffer","TextDecoder","decode","input","JSON","stringify","paddedVersionString","parts","map","padStart","isObj","x","getAutoExperimentChangeType","exp","urlPatterns","variations","variation","domMutations","_regexCache","evalCondition","obj","condition","savedGroups","entries","evalOr","evalAnd","evalConditionValue","getPath","path","current","isArray","isOperatorObject","op","evalOperatorCondition","isIn","includes","operator","check","elemMatch","passed","j","t","getType","conditions","cacheSettings","staleTTL","maxAge","cacheKey","backgroundSync","maxEntries","disableIdleStreams","idleStreamInterval","disableCache","helpers","fetchFeaturesCall","clientKey","headers","concat","fetchRemoteEvalCall","payload","options","method","body","eventSourceCall","_ref3","startIdleListener","idleTimeout","window","onVisibilityChange","visibilityState","clearTimeout","streams","channel","state","enableChannel","onHidden","addEventListener","removeEventListener","stopIdleListener","localStorage","subscribedInstances","cacheInitialized","cache","activeFetches","supportsSSE","subscribe","instance","getKey","subs","disableChannel","updatePersistentCache","setItem","apiHost","getApiInfo","getCacheKey","baseKey","isRemoteEval","getAttributes","cacheKeyAttributes","getCacheKeyAttributes","ca","fv","getForcedVariations","getUrl","cleanupCache","entriesWithTimestamps","_ref7","staleAt","getTime","sort","a","entriesToRemoveCount","Math","min","max","delete","onNewFeatureData","dateUpdated","Date","now","existing","sse","instances","setPayload","getPayload","refreshInstance","fetchFeatures","apiRequestHeaders","getApiHosts","getClientKey","remoteEval","promise","forcedVariations","forcedFeatures","getForcedFeatures","then","res","ok","status","json","startAutoRefresh","success","source","catch","forceSSE","arguments","streamingHost","streamingHostRequestHeaders","src","cb","event","parse","errors","onSSEError","readyState","delay","pow","random","onopen","onerror","close","isBrowser","SDK_VERSION","loadSDKVersion","GrowthBook","constructor","context","this","_ctx","_renderer","renderer","_trackedExperiments","_completedChangeIds","_trackedFeatures","debug","_subscriptions","_rtQueue","_rtTimer","ready","_assigned","_forcedFeatureValues","_attributeOverrides","_activeAutoExperiments","_triggeredExpKeys","_initialized","_redirectedUrl","_deferredTrackingCalls","_autoExperimentsAllowed","disableExperimentsOnLoad","isGbHost","hostname","features","enableDevMode","_growthbook","dispatchEvent","Event","experiments","_updateAllAutoExperiments","antiFlicker","_setAntiFlicker","stickyBucketService","stickyBucketAssignmentDocs","doc","saveAssignments","refreshStickyBuckets","_payload","decryptPayload","_decryptedPayload","_render","initSync","encryptedExperiments","encryptedFeatures","streaming","_refresh","allowStale","autoRefresh","subscribeToChanges","_canSubscribe","defaultHost","apiHostRequestHeaders","getFeatures","getExperiments","getDecryptedPayload","timeout","skipCache","_ref4","_ref5","minStaleAt","getItem","_ref6","cleanupFn","initializeCache","Promise","resolve","timer","resolved","finish","promiseTimeout","fetchFeaturesWithCache","setFeatures","featuresJSON","setExperiments","experimentsJSON","encryptedSavedGroups","_refreshForRemoteEval","setAttributes","overrides","vars","setForcedFeatures","getStickyBucketAssignmentDocs","getCompletedChangeIds","_this$_ctx$background","getAllResults","destroy","s","undo","setRenderer","forceVariation","run","experiment","result","_run","_fireSubscriptions","triggerExperiment","_runAutoExperiment","triggerAutoExperiments","forceRerun","manual","_isAutoExperimentBlockedByContext","_getResult","valueHash","inExperiment","_undoActiveAutoExperiment","changeType","urlRedirect","persistQueryString","oldUrl","newUrl","currUrl","redirectUrl","toString","mergeQueryStrings","_getContextUrl","log","id","navigate","_getNavigateFunction","_this$_ctx$navigateDe","navigateDelay","applyDomChangesCallback","_applyDOMChanges","prev","variationId","_trackFeatureUsage","stringifiedValue","onFeatureUsage","on","q","realtimeKey","encodeURIComponent","mode","realtimeInterval","_getFeatureResult","ruleId","ret","off","experimentResult","isOn","evalFeature","isOff","getFeatureValue","defaultValue","feature","_evalFeature","evalCtx","evaluatedFeatures","rules","rule","parentConditions","parentCondition","parentResult","gate","filters","_isFilteredOut","_conditionPasses","_isIncludedInRollout","hashAttribute","disableStickyBucketing","fallbackAttribute","coverage","hashVersion","tracks","_track","force","weights","bucketVersion","minBucketVersion","namespace","meta","ranges","phase","passthrough","hashValue","_getHashAttribute","r","featureId","numVariations","enabled","_mergeOverrides","qsOverride","search","kv","parseInt","getQueryStringOverride","active","assigned","foundStickyBucket","stickyBucketVersionIsBlocked","versionIsBlocked","_getStickyBucketVariation","expKey","expBucketVersion","expHashAttribute","expFallbackAttribute","expMinBucketVersion","expMeta","inNamespace","groups","_hasGroupOverlap","_urlIsValid","chooseVariation","equal","fill","totalWeight","reduce","w","sum","cumulative","start","getBucketRanges","qaMode","changed","attrKey","_generateStickyBucketAssignmentDoc","_getStickyBucketExperimentKey","changeId","msg","ctx","getDeferredTrackingCalls","values","setDeferredTrackingCalls","calls","_getTrackKey","fireDeferredTrackingCalls","trackingCallback","call","setTrackingCallback","callback","o","assign","fallback","user","variationIndex","hashUsed","bucket","stickyBucketUsed","location","urlRegex","pathOnly","expGroups","disableVisualExperiments","disableJsInjection","js","disableUrlRedirectExperiments","disableCrossOriginUrlRedirectExperiments","protocol","blockedChangeIds","getRedirectUrl","_this$_ctx$antiFlicke","styleTag","head","appendChild","classList","remove","antiFlickerTimeout","changes","css","script","jsInjectionNonce","nonce","fn","_deriveStickyBucketIdentifierAttributes","_getStickyBucketAttributes","getAllAssignments","_getStickyBucketAssignments","hashKey","fallbackValue","fallbackKey","assignments","variationKey","findIndex","experimentKey","experimentBucketVersion","stickyBucketIdentifierAttributes","attributeName","attributeValue","existingAssignments","newAssignments","initStatus","static","f","startDate","start_date","start_time","endDate","end_date","end_time","isFeatureActive","templateContainer","rel","cssBuild","template","file","contextualData","assetsVersion","jsBuild","templates","htmlText","text","firstChild","p","_instance","GROWTHBOOK_KEY","dataLayer","experiment_id","variation_id","handleTemplateFeature","us","adamastor","getSubscriptionSettings","user_browser_id","logged_in","isLoggedIn","subscriber","isSubscriber","subscriptions_plans","getSubscriptionsProductsIds","engagement","getUserEngagement","zone_type","pageTargeting","zoneType","sub_zone_type","subZoneType","post_type","postType","post_is_exclusive","exclusive","top_category","topCategory","category","device_category","getDeviceCategory","can_be_metered","canBeMetered","page_slug","pageSlug","getSessionProfile","sub","can_comment","canComment","exclusive_articles","exclusiveArticles","exclusive_newsletters","exclusiveNewsletters","exclusive_opinion","exclusiveOpinion","exclusive_podcasts","exclusivePodcasts","less_pub","lessPub","max_offer_articles","maxOfferArticles","remove_pub","removePub","subscription_source","subscription","products","google_subscription_linked","metadata","find","item","google_subscription_linked_show_date","Number","init","articlesCounter","post","isAnInitiative","iniativeMediaPartner","credits","creditAuthorName","categories","innerWidth","GrowthbookManager","mainFolder","buildFolder","gb","getInstance","fa","obs_tp","paywallTriggered","paywallMetered","obs_ads","trigger"],"sourceRoot":""}