@financial-times/cmp-client 2.0.2 → 2.0.3

package/dist/client.cjs

@@ -0,0 +1,2657 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const properties = require("./properties.cjs");
+const request = (url, { credentials = "omit" } = {}) => {
+  return fetch(`https://session-next.ft.com${url}`, {
+    credentials,
+    useCorsProxy: true
+  }).then((response) => {
+    if (response.ok) {
+      return response.json();
+    } else {
+      return response.text().then((text) => {
+        throw new Error(`Next session responded with "${text}" (${response.status})`);
+      });
+    }
+  }).catch((err) => {
+    document.body.dispatchEvent(new CustomEvent("oErrors.log", {
+      bubbles: true,
+      detail: {
+        error: err,
+        info: {
+          component: "next-session-client"
+        }
+      }
+    }));
+  });
+};
+let detailsCache = {};
+const cache = (name, value) => {
+  if (typeof name === "object") {
+    detailsCache = name;
+    return;
+  }
+  if (typeof name === "string" && typeof value === "string") {
+    detailsCache[name] = value;
+    return;
+  }
+  if (typeof name === "string" && typeof value === "undefined") {
+    return detailsCache[name] || null;
+  }
+  if (typeof name === "undefined" && typeof value === "undefined") {
+    return detailsCache;
+  }
+  throw new Error("Invalid arguments");
+};
+cache.clear = () => {
+  detailsCache = {};
+};
+const requests = {};
+const getSessionId = () => {
+  const [, sessionId] = /FTSession_s=([^;]+)/.exec(document.cookie) || [];
+  return sessionId;
+};
+const getUuid = () => {
+  const cachedUUID = cache("uuid");
+  if (cachedUUID) {
+    return Promise.resolve({ uuid: cachedUUID });
+  }
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    return Promise.resolve({ uuid: void 0 });
+  }
+  if (!requests.uuid) {
+    requests.uuid = request(`/sessions/s/${sessionId}`).then(({ uuid } = {}) => {
+      delete requests.uuid;
+      if (uuid) {
+        cache("uuid", uuid);
+      }
+      return { uuid };
+    });
+  }
+  return requests.uuid;
+};
+function encodeConfig(obj) {
+  let str = "";
+  for (const [key, val] of Object.entries(obj)) {
+    switch (typeof obj[key]) {
+      case "function":
+        str += `${key}:${val.toString().replace(/"/g, "'").replace(/\s/g, "")},`;
+        break;
+      case "string":
+        str += `${key}:"${val.replace(/"/g, "'").replace(/\s/g, "")}",`;
+        break;
+      case "object":
+        str += `${key}:{${encodeConfig(val)}},`;
+        break;
+      default:
+        str += `${key}:${val},`;
+        break;
+    }
+  }
+  return str.slice(0, -1);
+}
+function getSPConfig(config) {
+  return `window._sp_queue=[];window._sp_={config:{${encodeConfig(config)}}}`;
+}
+const scriptSources = {
+  cmpFrames: "https://cdn.privacy-mgmt.com/unified/wrapperMessagingWithoutDetection.js"
+};
+const scriptContent = {
+  getSPConfig,
+  tcfStub: `"use strict";function _typeof(t){return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}!function(){var t=function(){var t,e,o=[],n=window,r=n;for(;r;){try{if(r.frames.__tcfapiLocator){t=r;break}}catch(t){}if(r===n.top)break;r=r.parent}t||(!function t(){var e=n.document,o=!!n.frames.__tcfapiLocator;if(!o)if(e.body){var r=e.createElement("iframe");r.style.cssText="display:none",r.name="__tcfapiLocator",e.body.appendChild(r)}else setTimeout(t,5);return!o}(),n.__tcfapi=function(){for(var t=arguments.length,n=new Array(t),r=0;r<t;r++)n[r]=arguments[r];if(!n.length)return o;"setGdprApplies"===n[0]?n.length>3&&2===parseInt(n[1],10)&&"boolean"==typeof n[3]&&(e=n[3],"function"==typeof n[2]&&n[2]("set",!0)):"ping"===n[0]?"function"==typeof n[2]&&n[2]({gdprApplies:e,cmpLoaded:!1,cmpStatus:"stub"}):o.push(n)},n.addEventListener("message",(function(t){var e="string"==typeof t.data,o={};if(e)try{o=JSON.parse(t.data)}catch(t){}else o=t.data;var n="object"===_typeof(o)&&null!==o?o.__tcfapiCall:null;n&&window.__tcfapi(n.command,n.version,(function(o,r){var a={__tcfapiReturn:{returnValue:o,success:r,callId:n.callId}};t&&t.source&&t.source.postMessage&&t.source.postMessage(e?JSON.stringify(a):a,"*")}),n.parameter)}),!1))};"undefined"!=typeof module?module.exports=t:t()}();`,
+  uspStub: `"use strict";(function () { var e = false; var c = window; var t = document; function r() { if (!c.frames["__uspapiLocator"]) { if (t.body) { var a = t.body; var e = t.createElement("iframe"); e.style.cssText = "display:none"; e.name = "__uspapiLocator"; a.appendChild(e) } else { setTimeout(r, 5) } } } r(); function p() { var a = arguments; __uspapi.a = __uspapi.a || []; if (!a.length) { return __uspapi.a } else if (a[0] === "ping") { a[2]({ gdprAppliesGlobally: e, cmpLoaded: false }, true) } else { __uspapi.a.push([].slice.apply(a)) } } function l(t) { var r = typeof t.data === "string"; try { var a = r ? JSON.parse(t.data) : t.data; if (a.__cmpCall) { var n = a.__cmpCall; c.__uspapi(n.command, n.parameter, function (a, e) { var c = { __cmpReturn: { returnValue: a, success: e, callId: n.callId } }; t.source.postMessage(r ? JSON.stringify(c) : c, "*") }) } } catch (a) { } } if (typeof __uspapi !== "function") { c.__uspapi = p; __uspapi.msgHandler = l; c.addEventListener("message", l, false) } })();`
+};
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+class DecodingError extends Error {
+  /**
+   * constructor - constructs an DecodingError
+   *
+   * @param {string} msg - Decoding Error Message
+   * @return {undefined}
+   */
+  constructor(msg) {
+    super(msg);
+    this.name = "DecodingError";
+  }
+}
+class EncodingError extends Error {
+  /**
+   * constructor - constructs an EncodingError
+   *
+   * @param {string} msg - Encoding Error Message
+   * @return {undefined}
+   */
+  constructor(msg) {
+    super(msg);
+    this.name = "EncodingError";
+  }
+}
+class GVLError extends Error {
+  /**
+   * constructor - constructs a GVLError
+   *
+   * @param {string} msg - Error message to display
+   * @return {undefined}
+   */
+  constructor(msg) {
+    super(msg);
+    this.name = "GVLError";
+  }
+}
+class TCModelError extends Error {
+  /**
+   * constructor - constructs an TCModelError
+   *
+   * @param {string} fieldName - the errored field
+   * @param {string} passedValue - what was passed
+   * @return {undefined}
+   */
+  constructor(fieldName, passedValue, msg = "") {
+    super(`invalid value ${passedValue} passed for ${fieldName} ${msg}`);
+    this.name = "TCModelError";
+  }
+}
+class Base64Url {
+  /**
+   * encodes an arbitrary-length bitfield string into base64url
+   *
+   * @static
+   * @param {string} str - arbitrary-length bitfield string to be encoded to base64url
+   * @return {string} - base64url encoded result
+   */
+  static encode(str) {
+    if (!/^[0-1]+$/.test(str)) {
+      throw new EncodingError("Invalid bitField");
+    }
+    const padding = str.length % this.LCM;
+    str += padding ? "0".repeat(this.LCM - padding) : "";
+    let result = "";
+    for (let i = 0; i < str.length; i += this.BASIS) {
+      result += this.DICT[parseInt(str.substr(i, this.BASIS), 2)];
+    }
+    return result;
+  }
+  /**
+   * decodes a base64url encoded bitfield string
+   *
+   * @static
+   * @param {string} str - base64url encoded bitfield string to be decoded
+   * @return {string} - bitfield string
+   */
+  static decode(str) {
+    if (!/^[A-Za-z0-9\-_]+$/.test(str)) {
+      throw new DecodingError("Invalidly encoded Base64URL string");
+    }
+    let result = "";
+    for (let i = 0; i < str.length; i++) {
+      const strBits = this.REVERSE_DICT.get(str[i]).toString(2);
+      result += "0".repeat(this.BASIS - strBits.length) + strBits;
+    }
+    return result;
+  }
+}
+__publicField(Base64Url, "DICT", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
+__publicField(Base64Url, "REVERSE_DICT", /* @__PURE__ */ new Map([
+  ["A", 0],
+  ["B", 1],
+  ["C", 2],
+  ["D", 3],
+  ["E", 4],
+  ["F", 5],
+  ["G", 6],
+  ["H", 7],
+  ["I", 8],
+  ["J", 9],
+  ["K", 10],
+  ["L", 11],
+  ["M", 12],
+  ["N", 13],
+  ["O", 14],
+  ["P", 15],
+  ["Q", 16],
+  ["R", 17],
+  ["S", 18],
+  ["T", 19],
+  ["U", 20],
+  ["V", 21],
+  ["W", 22],
+  ["X", 23],
+  ["Y", 24],
+  ["Z", 25],
+  ["a", 26],
+  ["b", 27],
+  ["c", 28],
+  ["d", 29],
+  ["e", 30],
+  ["f", 31],
+  ["g", 32],
+  ["h", 33],
+  ["i", 34],
+  ["j", 35],
+  ["k", 36],
+  ["l", 37],
+  ["m", 38],
+  ["n", 39],
+  ["o", 40],
+  ["p", 41],
+  ["q", 42],
+  ["r", 43],
+  ["s", 44],
+  ["t", 45],
+  ["u", 46],
+  ["v", 47],
+  ["w", 48],
+  ["x", 49],
+  ["y", 50],
+  ["z", 51],
+  ["0", 52],
+  ["1", 53],
+  ["2", 54],
+  ["3", 55],
+  ["4", 56],
+  ["5", 57],
+  ["6", 58],
+  ["7", 59],
+  ["8", 60],
+  ["9", 61],
+  ["-", 62],
+  ["_", 63]
+]));
+__publicField(Base64Url, "BASIS", 6);
+__publicField(Base64Url, "LCM", 24);
+const _ConsentLanguages = class _ConsentLanguages2 {
+  has(key) {
+    return _ConsentLanguages2.langSet.has(key);
+  }
+  parseLanguage(lang) {
+    lang = lang.toUpperCase();
+    const primaryLanguage = lang.split("-")[0];
+    if (lang.length >= 2 && primaryLanguage.length == 2) {
+      if (_ConsentLanguages2.langSet.has(lang)) {
+        return lang;
+      } else if (_ConsentLanguages2.langSet.has(primaryLanguage)) {
+        return primaryLanguage;
+      }
+      const fullPrimaryLang = primaryLanguage + "-" + primaryLanguage;
+      if (_ConsentLanguages2.langSet.has(fullPrimaryLang)) {
+        return fullPrimaryLang;
+      }
+      for (const supportedLang of _ConsentLanguages2.langSet) {
+        if (supportedLang.indexOf(lang) !== -1 || supportedLang.indexOf(primaryLanguage) !== -1) {
+          return supportedLang;
+        }
+      }
+    }
+    throw new Error(`unsupported language ${lang}`);
+  }
+  forEach(callback) {
+    _ConsentLanguages2.langSet.forEach(callback);
+  }
+  get size() {
+    return _ConsentLanguages2.langSet.size;
+  }
+};
+__publicField(_ConsentLanguages, "langSet", /* @__PURE__ */ new Set([
+  "AR",
+  "BG",
+  "BS",
+  "CA",
+  "CS",
+  "DA",
+  "DE",
+  "EL",
+  "EN",
+  "ES",
+  "ET",
+  "EU",
+  "FI",
+  "FR",
+  "GL",
+  "HR",
+  "HU",
+  "IT",
+  "JA",
+  "LT",
+  "LV",
+  "MT",
+  "NL",
+  "NO",
+  "PL",
+  "PT-BR",
+  "PT-PT",
+  "RO",
+  "RU",
+  "SK",
+  "SL",
+  "SR-LATN",
+  "SR-CYRL",
+  "SV",
+  "TR",
+  "ZH"
+]));
+let ConsentLanguages = _ConsentLanguages;
+class Fields {
+}
+__publicField(Fields, "cmpId", "cmpId");
+__publicField(Fields, "cmpVersion", "cmpVersion");
+__publicField(Fields, "consentLanguage", "consentLanguage");
+__publicField(Fields, "consentScreen", "consentScreen");
+__publicField(Fields, "created", "created");
+__publicField(Fields, "supportOOB", "supportOOB");
+__publicField(Fields, "isServiceSpecific", "isServiceSpecific");
+__publicField(Fields, "lastUpdated", "lastUpdated");
+__publicField(Fields, "numCustomPurposes", "numCustomPurposes");
+__publicField(Fields, "policyVersion", "policyVersion");
+__publicField(Fields, "publisherCountryCode", "publisherCountryCode");
+__publicField(Fields, "publisherCustomConsents", "publisherCustomConsents");
+__publicField(Fields, "publisherCustomLegitimateInterests", "publisherCustomLegitimateInterests");
+__publicField(Fields, "publisherLegitimateInterests", "publisherLegitimateInterests");
+__publicField(Fields, "publisherConsents", "publisherConsents");
+__publicField(Fields, "publisherRestrictions", "publisherRestrictions");
+__publicField(Fields, "purposeConsents", "purposeConsents");
+__publicField(Fields, "purposeLegitimateInterests", "purposeLegitimateInterests");
+__publicField(Fields, "purposeOneTreatment", "purposeOneTreatment");
+__publicField(Fields, "specialFeatureOptins", "specialFeatureOptins");
+__publicField(Fields, "useNonStandardTexts", "useNonStandardTexts");
+__publicField(Fields, "vendorConsents", "vendorConsents");
+__publicField(Fields, "vendorLegitimateInterests", "vendorLegitimateInterests");
+__publicField(Fields, "vendorListVersion", "vendorListVersion");
+__publicField(Fields, "vendorsAllowed", "vendorsAllowed");
+__publicField(Fields, "vendorsDisclosed", "vendorsDisclosed");
+__publicField(Fields, "version", "version");
+class Cloneable {
+  /**
+   * clone - returns a copy of the classes with new values and not references
+   *
+   * @return {T}
+   */
+  clone() {
+    const myClone = new this.constructor();
+    const keys = Object.keys(this);
+    keys.forEach((key) => {
+      const value = this.deepClone(this[key]);
+      if (value !== void 0) {
+        myClone[key] = value;
+      }
+    });
+    return myClone;
+  }
+  /**
+   * deepClone - recursive function that makes copies of reference values
+   *
+   * @param {unknown} item
+   * @return {unknown}
+   */
+  deepClone(item) {
+    const itsType = typeof item;
+    if (itsType === "number" || itsType === "string" || itsType === "boolean") {
+      return item;
+    } else if (item !== null && itsType === "object") {
+      if (typeof item.clone === "function") {
+        return item.clone();
+      } else if (item instanceof Date) {
+        return new Date(item.getTime());
+      } else if (item[Symbol.iterator] !== void 0) {
+        const ar = [];
+        for (const subItem of item) {
+          ar.push(this.deepClone(subItem));
+        }
+        if (item instanceof Array) {
+          return ar;
+        } else {
+          return new item.constructor(ar);
+        }
+      } else {
+        const retr = {};
+        for (const prop in item) {
+          if (item.hasOwnProperty(prop)) {
+            retr[prop] = this.deepClone(item[prop]);
+          }
+        }
+        return retr;
+      }
+    }
+  }
+}
+var RestrictionType;
+(function(RestrictionType2) {
+  RestrictionType2[RestrictionType2["NOT_ALLOWED"] = 0] = "NOT_ALLOWED";
+  RestrictionType2[RestrictionType2["REQUIRE_CONSENT"] = 1] = "REQUIRE_CONSENT";
+  RestrictionType2[RestrictionType2["REQUIRE_LI"] = 2] = "REQUIRE_LI";
+})(RestrictionType || (RestrictionType = {}));
+const _PurposeRestriction = class _PurposeRestriction2 extends Cloneable {
+  /**
+   * constructor
+   *
+   * @param {number} purposeId? - may optionally pass the purposeId into the
+   * constructor
+   * @param {RestrictionType} restrictionType? - may
+   * optionally pass the restrictionType into the constructor
+   * @return {undefined}
+   */
+  constructor(purposeId, restrictionType) {
+    super();
+    __publicField(this, "purposeId_");
+    __publicField(this, "restrictionType");
+    if (purposeId !== void 0) {
+      this.purposeId = purposeId;
+    }
+    if (restrictionType !== void 0) {
+      this.restrictionType = restrictionType;
+    }
+  }
+  static unHash(hash) {
+    const splitUp = hash.split(this.hashSeparator);
+    const purpRestriction = new _PurposeRestriction2();
+    if (splitUp.length !== 2) {
+      throw new TCModelError("hash", hash);
+    }
+    purpRestriction.purposeId = parseInt(splitUp[0], 10);
+    purpRestriction.restrictionType = parseInt(splitUp[1], 10);
+    return purpRestriction;
+  }
+  get hash() {
+    if (!this.isValid()) {
+      throw new Error("cannot hash invalid PurposeRestriction");
+    }
+    return `${this.purposeId}${_PurposeRestriction2.hashSeparator}${this.restrictionType}`;
+  }
+  /**
+   * @return {number} The purpose Id associated with a publisher
+   * purpose-by-vendor restriction that resulted in a different consent or LI
+   * status than the consent or LI purposes allowed lists.
+   */
+  get purposeId() {
+    return this.purposeId_;
+  }
+  /**
+   * @param {number} idNum - The purpose Id associated with a publisher
+   * purpose-by-vendor restriction that resulted in a different consent or LI
+   * status than the consent or LI purposes allowed lists.
+   */
+  set purposeId(idNum) {
+    this.purposeId_ = idNum;
+  }
+  isValid() {
+    return Number.isInteger(this.purposeId) && this.purposeId > 0 && (this.restrictionType === RestrictionType.NOT_ALLOWED || this.restrictionType === RestrictionType.REQUIRE_CONSENT || this.restrictionType === RestrictionType.REQUIRE_LI);
+  }
+  isSameAs(otherPR) {
+    return this.purposeId === otherPR.purposeId && this.restrictionType === otherPR.restrictionType;
+  }
+};
+__publicField(_PurposeRestriction, "hashSeparator", "-");
+let PurposeRestriction = _PurposeRestriction;
+class PurposeRestrictionVector extends Cloneable {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "bitLength", 0);
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+    __publicField(this, "gvl_");
+  }
+  has(hash) {
+    return this.map.has(hash);
+  }
+  isOkToHave(restrictionType, purposeId, vendorId) {
+    var _a2;
+    let result = true;
+    if ((_a2 = this.gvl) == null ? void 0 : _a2.vendors) {
+      const vendor = this.gvl.vendors[vendorId];
+      if (vendor) {
+        if (restrictionType === RestrictionType.NOT_ALLOWED) {
+          result = vendor.legIntPurposes.includes(purposeId) || vendor.purposes.includes(purposeId);
+        } else if (vendor.flexiblePurposes.length) {
+          switch (restrictionType) {
+            case RestrictionType.REQUIRE_CONSENT:
+              result = vendor.flexiblePurposes.includes(purposeId) && vendor.legIntPurposes.includes(purposeId);
+              break;
+            case RestrictionType.REQUIRE_LI:
+              result = vendor.flexiblePurposes.includes(purposeId) && vendor.purposes.includes(purposeId);
+              break;
+          }
+        } else {
+          result = false;
+        }
+      } else {
+        result = false;
+      }
+    }
+    return result;
+  }
+  /**
+   * add - adds a given Vendor ID under a given Purpose Restriction
+   *
+   * @param {number} vendorId
+   * @param {PurposeRestriction} purposeRestriction
+   * @return {void}
+   */
+  add(vendorId, purposeRestriction) {
+    if (this.isOkToHave(purposeRestriction.restrictionType, purposeRestriction.purposeId, vendorId)) {
+      const hash = purposeRestriction.hash;
+      if (!this.has(hash)) {
+        this.map.set(hash, /* @__PURE__ */ new Set());
+        this.bitLength = 0;
+      }
+      this.map.get(hash).add(vendorId);
+    }
+  }
+  /**
+   * restrictPurposeToLegalBasis - adds all Vendors under a given Purpose Restriction
+   *
+   * @param {PurposeRestriction} purposeRestriction
+   * @return {void}
+   */
+  restrictPurposeToLegalBasis(purposeRestriction) {
+    const vendors = Array.from(this.gvl.vendorIds);
+    const hash = purposeRestriction.hash;
+    const lastEntry = vendors[vendors.length - 1];
+    const values = [...Array(lastEntry).keys()].map((i) => i + 1);
+    if (!this.has(hash)) {
+      this.map.set(hash, new Set(values));
+      this.bitLength = 0;
+    } else {
+      for (let i = 1; i <= lastEntry; i++) {
+        this.map.get(hash).add(i);
+      }
+    }
+  }
+  /**
+   * getVendors - returns array of vendor ids optionally narrowed by a given
+   * Purpose Restriction.  If no purpose restriction is passed then all vendor
+   * ids will be returned.  One can expect this result to be a unique set of
+   * ids no duplicates.
+   *
+   * @param {PurposeRestriction} [purposeRestriction] - optionally passed to
+   * get only Vendor IDs restricted under the given Purpose Restriction
+   * @return {number[]} - Unique ID set of vendors
+   */
+  getVendors(purposeRestriction) {
+    let vendorIds = [];
+    if (purposeRestriction) {
+      const hash = purposeRestriction.hash;
+      if (this.has(hash)) {
+        vendorIds = Array.from(this.map.get(hash));
+      }
+    } else {
+      const vendorSet = /* @__PURE__ */ new Set();
+      this.map.forEach((set) => {
+        set.forEach((vendorId) => {
+          vendorSet.add(vendorId);
+        });
+      });
+      vendorIds = Array.from(vendorSet);
+    }
+    return vendorIds.sort((a, b) => a - b);
+  }
+  getRestrictionType(vendorId, purposeId) {
+    let rType;
+    this.getRestrictions(vendorId).forEach((purposeRestriction) => {
+      if (purposeRestriction.purposeId === purposeId) {
+        if (rType === void 0 || rType > purposeRestriction.restrictionType) {
+          rType = purposeRestriction.restrictionType;
+        }
+      }
+    });
+    return rType;
+  }
+  /**
+   * vendorHasRestriction - determines whether a given Vendor ID is under a
+   * given Purpose Restriction
+   *
+   * @param {number} vendorId
+   * @param {PurposeRestriction} purposeRestriction
+   * @return {boolean} - true if the give Vendor ID is under the given Purpose
+   * Restriction
+   */
+  vendorHasRestriction(vendorId, purposeRestriction) {
+    let has = false;
+    const restrictions = this.getRestrictions(vendorId);
+    for (let i = 0; i < restrictions.length && !has; i++) {
+      has = purposeRestriction.isSameAs(restrictions[i]);
+    }
+    return has;
+  }
+  /**
+   * getMaxVendorId - gets the Maximum Vendor ID regardless of Purpose
+   * Restriction
+   *
+   * @return {number} - maximum Vendor ID
+   */
+  getMaxVendorId() {
+    let retr = 0;
+    this.map.forEach((set) => {
+      retr = Math.max(Array.from(set)[set.size - 1], retr);
+    });
+    return retr;
+  }
+  getRestrictions(vendorId) {
+    const retr = [];
+    this.map.forEach((set, hash) => {
+      if (vendorId) {
+        if (set.has(vendorId)) {
+          retr.push(PurposeRestriction.unHash(hash));
+        }
+      } else {
+        retr.push(PurposeRestriction.unHash(hash));
+      }
+    });
+    return retr;
+  }
+  getPurposes() {
+    const purposeIds = /* @__PURE__ */ new Set();
+    this.map.forEach((set, hash) => {
+      purposeIds.add(PurposeRestriction.unHash(hash).purposeId);
+    });
+    return Array.from(purposeIds);
+  }
+  /**
+   * remove - removes Vendor ID from a Purpose Restriction
+   *
+   * @param {number} vendorId
+   * @param {PurposeRestriction} purposeRestriction
+   * @return {void}
+   */
+  remove(vendorId, purposeRestriction) {
+    const hash = purposeRestriction.hash;
+    const set = this.map.get(hash);
+    if (set) {
+      set.delete(vendorId);
+      if (set.size == 0) {
+        this.map.delete(hash);
+        this.bitLength = 0;
+      }
+    }
+  }
+  /**
+   * Essential for being able to determine whether we can actually set a
+   * purpose restriction since they have to have a flexible legal basis
+   *
+   * @param {GVL} value - the GVL instance
+   */
+  set gvl(value) {
+    if (!this.gvl_) {
+      this.gvl_ = value;
+      this.map.forEach((set, hash) => {
+        const purposeRestriction = PurposeRestriction.unHash(hash);
+        const vendors = Array.from(set);
+        vendors.forEach((vendorId) => {
+          if (!this.isOkToHave(purposeRestriction.restrictionType, purposeRestriction.purposeId, vendorId)) {
+            set.delete(vendorId);
+          }
+        });
+      });
+    }
+  }
+  /**
+   * gvl returns local copy of the GVL these restrictions apply to
+   *
+   * @return {GVL}
+   */
+  get gvl() {
+    return this.gvl_;
+  }
+  /**
+   * isEmpty - whether or not this vector has any restrictions in it
+   *
+   * @return {boolean}
+   */
+  isEmpty() {
+    return this.map.size === 0;
+  }
+  /**
+   * numRestrictions - returns the number of Purpose Restrictions.
+   *
+   * @return {number}
+   */
+  get numRestrictions() {
+    return this.map.size;
+  }
+}
+var DeviceDisclosureStorageAccessType;
+(function(DeviceDisclosureStorageAccessType2) {
+  DeviceDisclosureStorageAccessType2["COOKIE"] = "cookie";
+  DeviceDisclosureStorageAccessType2["WEB"] = "web";
+  DeviceDisclosureStorageAccessType2["APP"] = "app";
+})(DeviceDisclosureStorageAccessType || (DeviceDisclosureStorageAccessType = {}));
+var Segment;
+(function(Segment2) {
+  Segment2["CORE"] = "core";
+  Segment2["VENDORS_DISCLOSED"] = "vendorsDisclosed";
+  Segment2["VENDORS_ALLOWED"] = "vendorsAllowed";
+  Segment2["PUBLISHER_TC"] = "publisherTC";
+})(Segment || (Segment = {}));
+class SegmentIDs {
+}
+__publicField(SegmentIDs, "ID_TO_KEY", [
+  Segment.CORE,
+  Segment.VENDORS_DISCLOSED,
+  Segment.VENDORS_ALLOWED,
+  Segment.PUBLISHER_TC
+]);
+__publicField(SegmentIDs, "KEY_TO_ID", {
+  [Segment.CORE]: 0,
+  [Segment.VENDORS_DISCLOSED]: 1,
+  [Segment.VENDORS_ALLOWED]: 2,
+  [Segment.PUBLISHER_TC]: 3
+});
+class Vector extends Cloneable {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "bitLength", 0);
+    __publicField(this, "maxId_", 0);
+    __publicField(this, "set_", /* @__PURE__ */ new Set());
+  }
+  *[Symbol.iterator]() {
+    for (let i = 1; i <= this.maxId; i++) {
+      yield [i, this.has(i)];
+    }
+  }
+  /**
+   * values()
+   *
+   * @return {IterableIterator<number>} - returns an iterator of the positive
+   * values in the set
+   */
+  values() {
+    return this.set_.values();
+  }
+  /**
+   * maxId
+   *
+   * @return {number} - the highest id in this Vector
+   */
+  get maxId() {
+    return this.maxId_;
+  }
+  /**
+   * get
+   *
+   * @param {number} id - key for value to check
+   * @return {boolean} - value of that key, if never set it will be false
+   */
+  has(id) {
+    return this.set_.has(id);
+  }
+  /**
+   * unset
+   *
+   * @param {SingleIDOrCollection} id - id or ids to unset
+   * @return {void}
+   */
+  unset(id) {
+    if (Array.isArray(id)) {
+      id.forEach((id2) => this.unset(id2));
+    } else if (typeof id === "object") {
+      this.unset(Object.keys(id).map((strId) => Number(strId)));
+    } else {
+      this.set_.delete(Number(id));
+      this.bitLength = 0;
+      if (id === this.maxId) {
+        this.maxId_ = 0;
+        this.set_.forEach((id2) => {
+          this.maxId_ = Math.max(this.maxId, id2);
+        });
+      }
+    }
+  }
+  isIntMap(item) {
+    let result = typeof item === "object";
+    result = result && Object.keys(item).every((key) => {
+      let itemResult = Number.isInteger(parseInt(key, 10));
+      itemResult = itemResult && this.isValidNumber(item[key].id);
+      itemResult = itemResult && item[key].name !== void 0;
+      return itemResult;
+    });
+    return result;
+  }
+  isValidNumber(item) {
+    return parseInt(item, 10) > 0;
+  }
+  isSet(item) {
+    let result = false;
+    if (item instanceof Set) {
+      result = Array.from(item).every(this.isValidNumber);
+    }
+    return result;
+  }
+  /**
+   * set - sets an item assumed to be a truthy value by its presence
+   *
+   * @param {SingleIDOrCollection} item - May be a single id (positive integer)
+   * or collection of ids in a set, GVL Int Map, or Array.
+   *
+   * @return {void}
+   */
+  set(item) {
+    if (Array.isArray(item)) {
+      item.forEach((item2) => this.set(item2));
+    } else if (this.isSet(item)) {
+      this.set(Array.from(item));
+    } else if (this.isIntMap(item)) {
+      this.set(Object.keys(item).map((strId) => Number(strId)));
+    } else if (this.isValidNumber(item)) {
+      this.set_.add(item);
+      this.maxId_ = Math.max(this.maxId, item);
+      this.bitLength = 0;
+    } else {
+      throw new TCModelError("set()", item, "must be positive integer array, positive integer, Set<number>, or IntMap");
+    }
+  }
+  empty() {
+    this.set_ = /* @__PURE__ */ new Set();
+  }
+  /**
+   * forEach - to traverse from id=1 to id=maxId in a sequential non-sparse manner
+   *
+   *
+   * @param {forEachCallback} callback - callback to execute
+   * @return {void}
+   *
+   * @callback forEachCallback
+   * @param {boolean} value - whether or not this id exists in the vector
+   * @param {number} id - the id number of the current iteration
+   */
+  forEach(callback) {
+    for (let i = 1; i <= this.maxId; i++) {
+      callback(this.has(i), i);
+    }
+  }
+  get size() {
+    return this.set_.size;
+  }
+  setAll(intMap) {
+    this.set(intMap);
+  }
+}
+class BitLength {
+}
+_a = Fields.cmpId, _b = Fields.cmpVersion, _c = Fields.consentLanguage, _d = Fields.consentScreen, _e = Fields.created, _f = Fields.isServiceSpecific, _g = Fields.lastUpdated, _h = Fields.policyVersion, _i = Fields.publisherCountryCode, _j = Fields.publisherLegitimateInterests, _k = Fields.publisherConsents, _l = Fields.purposeConsents, _m = Fields.purposeLegitimateInterests, _n = Fields.purposeOneTreatment, _o = Fields.specialFeatureOptins, _p = Fields.useNonStandardTexts, _q = Fields.vendorListVersion, _r = Fields.version;
+__publicField(BitLength, _a, 12);
+__publicField(BitLength, _b, 12);
+__publicField(BitLength, _c, 12);
+__publicField(BitLength, _d, 6);
+__publicField(BitLength, _e, 36);
+__publicField(BitLength, _f, 1);
+__publicField(BitLength, _g, 36);
+__publicField(BitLength, _h, 6);
+__publicField(BitLength, _i, 12);
+__publicField(BitLength, _j, 24);
+__publicField(BitLength, _k, 24);
+__publicField(BitLength, _l, 24);
+__publicField(BitLength, _m, 24);
+__publicField(BitLength, _n, 1);
+__publicField(BitLength, _o, 12);
+__publicField(BitLength, _p, 1);
+__publicField(BitLength, _q, 12);
+__publicField(BitLength, _r, 6);
+__publicField(BitLength, "anyBoolean", 1);
+__publicField(BitLength, "encodingType", 1);
+__publicField(BitLength, "maxId", 16);
+__publicField(BitLength, "numCustomPurposes", 6);
+__publicField(BitLength, "numEntries", 12);
+__publicField(BitLength, "numRestrictions", 12);
+__publicField(BitLength, "purposeId", 6);
+__publicField(BitLength, "restrictionType", 2);
+__publicField(BitLength, "segmentType", 3);
+__publicField(BitLength, "singleOrRange", 1);
+__publicField(BitLength, "vendorId", 16);
+class BooleanEncoder {
+  static encode(value) {
+    return String(Number(value));
+  }
+  static decode(value) {
+    return value === "1";
+  }
+}
+class IntEncoder {
+  static encode(value, numBits) {
+    let bitString;
+    if (typeof value === "string") {
+      value = parseInt(value, 10);
+    }
+    bitString = value.toString(2);
+    if (bitString.length > numBits || value < 0) {
+      throw new EncodingError(`${value} too large to encode into ${numBits}`);
+    }
+    if (bitString.length < numBits) {
+      bitString = "0".repeat(numBits - bitString.length) + bitString;
+    }
+    return bitString;
+  }
+  static decode(value, numBits) {
+    if (numBits !== value.length) {
+      throw new DecodingError("invalid bit length");
+    }
+    return parseInt(value, 2);
+  }
+}
+class DateEncoder {
+  static encode(value, numBits) {
+    return IntEncoder.encode(Math.round(value.getTime() / 100), numBits);
+  }
+  static decode(value, numBits) {
+    if (numBits !== value.length) {
+      throw new DecodingError("invalid bit length");
+    }
+    const date = /* @__PURE__ */ new Date();
+    date.setTime(IntEncoder.decode(value, numBits) * 100);
+    return date;
+  }
+}
+class FixedVectorEncoder {
+  static encode(value, numBits) {
+    let bitString = "";
+    for (let i = 1; i <= numBits; i++) {
+      bitString += BooleanEncoder.encode(value.has(i));
+    }
+    return bitString;
+  }
+  static decode(value, numBits) {
+    if (value.length !== numBits) {
+      throw new DecodingError("bitfield encoding length mismatch");
+    }
+    const vector = new Vector();
+    for (let i = 1; i <= numBits; i++) {
+      if (BooleanEncoder.decode(value[i - 1])) {
+        vector.set(i);
+      }
+    }
+    vector.bitLength = value.length;
+    return vector;
+  }
+}
+class LangEncoder {
+  static encode(value, numBits) {
+    value = value.toUpperCase();
+    const ASCII_START = 65;
+    const firstLetter = value.charCodeAt(0) - ASCII_START;
+    const secondLetter = value.charCodeAt(1) - ASCII_START;
+    if (firstLetter < 0 || firstLetter > 25 || secondLetter < 0 || secondLetter > 25) {
+      throw new EncodingError(`invalid language code: ${value}`);
+    }
+    if (numBits % 2 === 1) {
+      throw new EncodingError(`numBits must be even, ${numBits} is not valid`);
+    }
+    numBits = numBits / 2;
+    const firstLetterBString = IntEncoder.encode(firstLetter, numBits);
+    const secondLetterBString = IntEncoder.encode(secondLetter, numBits);
+    return firstLetterBString + secondLetterBString;
+  }
+  static decode(value, numBits) {
+    let retr;
+    if (numBits === value.length && !(value.length % 2)) {
+      const ASCII_START = 65;
+      const mid = value.length / 2;
+      const firstLetter = IntEncoder.decode(value.slice(0, mid), mid) + ASCII_START;
+      const secondLetter = IntEncoder.decode(value.slice(mid), mid) + ASCII_START;
+      retr = String.fromCharCode(firstLetter) + String.fromCharCode(secondLetter);
+    } else {
+      throw new DecodingError("invalid bit length for language");
+    }
+    return retr;
+  }
+}
+class PurposeRestrictionVectorEncoder {
+  static encode(prVector) {
+    let bitString = IntEncoder.encode(prVector.numRestrictions, BitLength.numRestrictions);
+    if (!prVector.isEmpty()) {
+      const nextGvlVendor = (vendorId, lastVendorId) => {
+        for (let nextId = vendorId + 1; nextId <= lastVendorId; nextId++) {
+          if (prVector.gvl.vendorIds.has(nextId)) {
+            return nextId;
+          }
+        }
+        return vendorId;
+      };
+      prVector.getRestrictions().forEach((purpRestriction) => {
+        bitString += IntEncoder.encode(purpRestriction.purposeId, BitLength.purposeId);
+        bitString += IntEncoder.encode(purpRestriction.restrictionType, BitLength.restrictionType);
+        const vendors = prVector.getVendors(purpRestriction);
+        const len = vendors.length;
+        let numEntries = 0;
+        let startId = 0;
+        let rangeField = "";
+        for (let i = 0; i < len; i++) {
+          const vendorId = vendors[i];
+          if (startId === 0) {
+            numEntries++;
+            startId = vendorId;
+          }
+          if (i === len - 1 || vendors[i + 1] > nextGvlVendor(vendorId, vendors[len - 1])) {
+            const isRange = !(vendorId === startId);
+            rangeField += BooleanEncoder.encode(isRange);
+            rangeField += IntEncoder.encode(startId, BitLength.vendorId);
+            if (isRange) {
+              rangeField += IntEncoder.encode(vendorId, BitLength.vendorId);
+            }
+            startId = 0;
+          }
+        }
+        bitString += IntEncoder.encode(numEntries, BitLength.numEntries);
+        bitString += rangeField;
+      });
+    }
+    return bitString;
+  }
+  static decode(encodedString) {
+    let index = 0;
+    const vector = new PurposeRestrictionVector();
+    const numRestrictions = IntEncoder.decode(encodedString.substr(index, BitLength.numRestrictions), BitLength.numRestrictions);
+    index += BitLength.numRestrictions;
+    for (let i = 0; i < numRestrictions; i++) {
+      const purposeId = IntEncoder.decode(encodedString.substr(index, BitLength.purposeId), BitLength.purposeId);
+      index += BitLength.purposeId;
+      const restrictionType = IntEncoder.decode(encodedString.substr(index, BitLength.restrictionType), BitLength.restrictionType);
+      index += BitLength.restrictionType;
+      const purposeRestriction = new PurposeRestriction(purposeId, restrictionType);
+      const numEntries = IntEncoder.decode(encodedString.substr(index, BitLength.numEntries), BitLength.numEntries);
+      index += BitLength.numEntries;
+      for (let j = 0; j < numEntries; j++) {
+        const isARange = BooleanEncoder.decode(encodedString.substr(index, BitLength.anyBoolean));
+        index += BitLength.anyBoolean;
+        const startOrOnlyVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+        index += BitLength.vendorId;
+        if (isARange) {
+          const endVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+          index += BitLength.vendorId;
+          if (endVendorId < startOrOnlyVendorId) {
+            throw new DecodingError(`Invalid RangeEntry: endVendorId ${endVendorId} is less than ${startOrOnlyVendorId}`);
+          }
+          for (let k = startOrOnlyVendorId; k <= endVendorId; k++) {
+            vector.add(k, purposeRestriction);
+          }
+        } else {
+          vector.add(startOrOnlyVendorId, purposeRestriction);
+        }
+      }
+    }
+    vector.bitLength = index;
+    return vector;
+  }
+}
+var VectorEncodingType;
+(function(VectorEncodingType2) {
+  VectorEncodingType2[VectorEncodingType2["FIELD"] = 0] = "FIELD";
+  VectorEncodingType2[VectorEncodingType2["RANGE"] = 1] = "RANGE";
+})(VectorEncodingType || (VectorEncodingType = {}));
+class VendorVectorEncoder {
+  static encode(value) {
+    const ranges = [];
+    let range = [];
+    let retrString = IntEncoder.encode(value.maxId, BitLength.maxId);
+    let bitField = "";
+    let rangeIsSmaller;
+    const headerLength = BitLength.maxId + BitLength.encodingType;
+    const bitFieldLength = headerLength + value.maxId;
+    const minRangeLength = BitLength.vendorId * 2 + BitLength.singleOrRange + BitLength.numEntries;
+    let rangeLength = headerLength + BitLength.numEntries;
+    value.forEach((curValue, i) => {
+      bitField += BooleanEncoder.encode(curValue);
+      rangeIsSmaller = value.maxId > minRangeLength && rangeLength < bitFieldLength;
+      if (rangeIsSmaller && curValue) {
+        const nextValue = value.has(i + 1);
+        if (!nextValue) {
+          range.push(i);
+          rangeLength += BitLength.vendorId;
+          ranges.push(range);
+          range = [];
+        } else if (range.length === 0) {
+          range.push(i);
+          rangeLength += BitLength.singleOrRange;
+          rangeLength += BitLength.vendorId;
+        }
+      }
+    });
+    if (rangeIsSmaller) {
+      retrString += String(VectorEncodingType.RANGE);
+      retrString += this.buildRangeEncoding(ranges);
+    } else {
+      retrString += String(VectorEncodingType.FIELD);
+      retrString += bitField;
+    }
+    return retrString;
+  }
+  static decode(value, version) {
+    let vector;
+    let index = 0;
+    const maxId = IntEncoder.decode(value.substr(index, BitLength.maxId), BitLength.maxId);
+    index += BitLength.maxId;
+    const encodingType = IntEncoder.decode(value.charAt(index), BitLength.encodingType);
+    index += BitLength.encodingType;
+    if (encodingType === VectorEncodingType.RANGE) {
+      vector = new Vector();
+      if (version === 1) {
+        if (value.substr(index, 1) === "1") {
+          throw new DecodingError("Unable to decode default consent=1");
+        }
+        index++;
+      }
+      const numEntries = IntEncoder.decode(value.substr(index, BitLength.numEntries), BitLength.numEntries);
+      index += BitLength.numEntries;
+      for (let i = 0; i < numEntries; i++) {
+        const isIdRange = BooleanEncoder.decode(value.charAt(index));
+        index += BitLength.singleOrRange;
+        const firstId = IntEncoder.decode(value.substr(index, BitLength.vendorId), BitLength.vendorId);
+        index += BitLength.vendorId;
+        if (isIdRange) {
+          const secondId = IntEncoder.decode(value.substr(index, BitLength.vendorId), BitLength.vendorId);
+          index += BitLength.vendorId;
+          for (let j = firstId; j <= secondId; j++) {
+            vector.set(j);
+          }
+        } else {
+          vector.set(firstId);
+        }
+      }
+    } else {
+      const bitField = value.substr(index, maxId);
+      index += maxId;
+      vector = FixedVectorEncoder.decode(bitField, maxId);
+    }
+    vector.bitLength = index;
+    return vector;
+  }
+  static buildRangeEncoding(ranges) {
+    const numEntries = ranges.length;
+    let rangeString = IntEncoder.encode(numEntries, BitLength.numEntries);
+    ranges.forEach((range) => {
+      const single = range.length === 1;
+      rangeString += BooleanEncoder.encode(!single);
+      rangeString += IntEncoder.encode(range[0], BitLength.vendorId);
+      if (!single) {
+        rangeString += IntEncoder.encode(range[1], BitLength.vendorId);
+      }
+    });
+    return rangeString;
+  }
+}
+function FieldEncoderMap() {
+  return {
+    [Fields.version]: IntEncoder,
+    [Fields.created]: DateEncoder,
+    [Fields.lastUpdated]: DateEncoder,
+    [Fields.cmpId]: IntEncoder,
+    [Fields.cmpVersion]: IntEncoder,
+    [Fields.consentScreen]: IntEncoder,
+    [Fields.consentLanguage]: LangEncoder,
+    [Fields.vendorListVersion]: IntEncoder,
+    [Fields.policyVersion]: IntEncoder,
+    [Fields.isServiceSpecific]: BooleanEncoder,
+    [Fields.useNonStandardTexts]: BooleanEncoder,
+    [Fields.specialFeatureOptins]: FixedVectorEncoder,
+    [Fields.purposeConsents]: FixedVectorEncoder,
+    [Fields.purposeLegitimateInterests]: FixedVectorEncoder,
+    [Fields.purposeOneTreatment]: BooleanEncoder,
+    [Fields.publisherCountryCode]: LangEncoder,
+    [Fields.vendorConsents]: VendorVectorEncoder,
+    [Fields.vendorLegitimateInterests]: VendorVectorEncoder,
+    [Fields.publisherRestrictions]: PurposeRestrictionVectorEncoder,
+    segmentType: IntEncoder,
+    [Fields.vendorsDisclosed]: VendorVectorEncoder,
+    [Fields.vendorsAllowed]: VendorVectorEncoder,
+    [Fields.publisherConsents]: FixedVectorEncoder,
+    [Fields.publisherLegitimateInterests]: FixedVectorEncoder,
+    [Fields.numCustomPurposes]: IntEncoder,
+    [Fields.publisherCustomConsents]: FixedVectorEncoder,
+    [Fields.publisherCustomLegitimateInterests]: FixedVectorEncoder
+  };
+}
+class FieldSequence {
+  constructor() {
+    __publicField(this, "1", {
+      [Segment.CORE]: [
+        Fields.version,
+        Fields.created,
+        Fields.lastUpdated,
+        Fields.cmpId,
+        Fields.cmpVersion,
+        Fields.consentScreen,
+        Fields.consentLanguage,
+        Fields.vendorListVersion,
+        Fields.purposeConsents,
+        Fields.vendorConsents
+      ]
+    });
+    __publicField(this, "2", {
+      [Segment.CORE]: [
+        Fields.version,
+        Fields.created,
+        Fields.lastUpdated,
+        Fields.cmpId,
+        Fields.cmpVersion,
+        Fields.consentScreen,
+        Fields.consentLanguage,
+        Fields.vendorListVersion,
+        Fields.policyVersion,
+        Fields.isServiceSpecific,
+        Fields.useNonStandardTexts,
+        Fields.specialFeatureOptins,
+        Fields.purposeConsents,
+        Fields.purposeLegitimateInterests,
+        Fields.purposeOneTreatment,
+        Fields.publisherCountryCode,
+        Fields.vendorConsents,
+        Fields.vendorLegitimateInterests,
+        Fields.publisherRestrictions
+      ],
+      [Segment.PUBLISHER_TC]: [
+        Fields.publisherConsents,
+        Fields.publisherLegitimateInterests,
+        Fields.numCustomPurposes,
+        Fields.publisherCustomConsents,
+        Fields.publisherCustomLegitimateInterests
+      ],
+      [Segment.VENDORS_ALLOWED]: [
+        Fields.vendorsAllowed
+      ],
+      [Segment.VENDORS_DISCLOSED]: [
+        Fields.vendorsDisclosed
+      ]
+    });
+  }
+}
+class SegmentSequence {
+  constructor(tcModel, options) {
+    __publicField(this, "1", [
+      Segment.CORE
+    ]);
+    __publicField(this, "2", [
+      Segment.CORE
+    ]);
+    if (tcModel.version === 2) {
+      if (tcModel.isServiceSpecific) {
+        this["2"].push(Segment.PUBLISHER_TC);
+      } else {
+        const isForVendors = !!(options && options.isForVendors);
+        if (!isForVendors || tcModel[Fields.supportOOB] === true) {
+          this["2"].push(Segment.VENDORS_DISCLOSED);
+        }
+        if (isForVendors) {
+          if (tcModel[Fields.supportOOB] && tcModel[Fields.vendorsAllowed].size > 0) {
+            this["2"].push(Segment.VENDORS_ALLOWED);
+          }
+          this["2"].push(Segment.PUBLISHER_TC);
+        }
+      }
+    }
+  }
+}
+class SegmentEncoder {
+  static encode(tcModel, segment) {
+    let sequence;
+    try {
+      sequence = this.fieldSequence[String(tcModel.version)][segment];
+    } catch (err) {
+      throw new EncodingError(`Unable to encode version: ${tcModel.version}, segment: ${segment}`);
+    }
+    let bitField = "";
+    if (segment !== Segment.CORE) {
+      bitField = IntEncoder.encode(SegmentIDs.KEY_TO_ID[segment], BitLength.segmentType);
+    }
+    const fieldEncoderMap = FieldEncoderMap();
+    sequence.forEach((key) => {
+      const value = tcModel[key];
+      const encoder = fieldEncoderMap[key];
+      let numBits = BitLength[key];
+      if (numBits === void 0) {
+        if (this.isPublisherCustom(key)) {
+          numBits = Number(tcModel[Fields.numCustomPurposes]);
+        }
+      }
+      try {
+        bitField += encoder.encode(value, numBits);
+      } catch (err) {
+        throw new EncodingError(`Error encoding ${segment}->${key}: ${err.message}`);
+      }
+    });
+    return Base64Url.encode(bitField);
+  }
+  static decode(encodedString, tcModel, segment) {
+    const bitField = Base64Url.decode(encodedString);
+    let bStringIdx = 0;
+    if (segment === Segment.CORE) {
+      tcModel.version = IntEncoder.decode(bitField.substr(bStringIdx, BitLength[Fields.version]), BitLength[Fields.version]);
+    }
+    if (segment !== Segment.CORE) {
+      bStringIdx += BitLength.segmentType;
+    }
+    const sequence = this.fieldSequence[String(tcModel.version)][segment];
+    const fieldEncoderMap = FieldEncoderMap();
+    sequence.forEach((key) => {
+      const encoder = fieldEncoderMap[key];
+      let numBits = BitLength[key];
+      if (numBits === void 0) {
+        if (this.isPublisherCustom(key)) {
+          numBits = Number(tcModel[Fields.numCustomPurposes]);
+        }
+      }
+      if (numBits !== 0) {
+        const bits = bitField.substr(bStringIdx, numBits);
+        if (encoder === VendorVectorEncoder) {
+          tcModel[key] = encoder.decode(bits, tcModel.version);
+        } else {
+          tcModel[key] = encoder.decode(bits, numBits);
+        }
+        if (Number.isInteger(numBits)) {
+          bStringIdx += numBits;
+        } else if (Number.isInteger(tcModel[key].bitLength)) {
+          bStringIdx += tcModel[key].bitLength;
+        } else {
+          throw new DecodingError(key);
+        }
+      }
+    });
+    return tcModel;
+  }
+  static isPublisherCustom(key) {
+    return key.indexOf("publisherCustom") === 0;
+  }
+}
+__publicField(SegmentEncoder, "fieldSequence", new FieldSequence());
+class SemanticPreEncoder {
+  static process(tcModel, options) {
+    const gvl = tcModel.gvl;
+    if (!gvl) {
+      throw new EncodingError("Unable to encode TCModel without a GVL");
+    }
+    if (!gvl.isReady) {
+      throw new EncodingError("Unable to encode TCModel tcModel.gvl.readyPromise is not resolved");
+    }
+    tcModel = tcModel.clone();
+    tcModel.consentLanguage = gvl.language.slice(0, 2).toUpperCase();
+    if ((options == null ? void 0 : options.version) > 0 && (options == null ? void 0 : options.version) <= this.processor.length) {
+      tcModel.version = options.version;
+    } else {
+      tcModel.version = this.processor.length;
+    }
+    const processorFunctionIndex = tcModel.version - 1;
+    if (!this.processor[processorFunctionIndex]) {
+      throw new EncodingError(`Invalid version: ${tcModel.version}`);
+    }
+    return this.processor[processorFunctionIndex](tcModel, gvl);
+  }
+}
+__publicField(SemanticPreEncoder, "processor", [
+  (tcModel) => tcModel,
+  (tcModel, gvl) => {
+    tcModel.publisherRestrictions.gvl = gvl;
+    tcModel.purposeLegitimateInterests.unset([1, 3, 4, 5, 6]);
+    const vectorToIntMap = /* @__PURE__ */ new Map();
+    vectorToIntMap.set("legIntPurposes", tcModel.vendorLegitimateInterests);
+    vectorToIntMap.set("purposes", tcModel.vendorConsents);
+    vectorToIntMap.forEach((vector, gvlVendorKey) => {
+      vector.forEach((value, vendorId) => {
+        if (value) {
+          const vendor = gvl.vendors[vendorId];
+          if (!vendor || vendor.deletedDate) {
+            vector.unset(vendorId);
+          } else if (vendor[gvlVendorKey].length === 0) {
+            if (gvlVendorKey === "legIntPurposes" && vendor["purposes"].length === 0 && vendor["legIntPurposes"].length === 0 && vendor["specialPurposes"].length > 0)
+              ;
+            else {
+              if (tcModel.isServiceSpecific) {
+                if (vendor.flexiblePurposes.length === 0) {
+                  vector.unset(vendorId);
+                } else {
+                  const restrictions = tcModel.publisherRestrictions.getRestrictions(vendorId);
+                  let isValid = false;
+                  for (let i = 0, len = restrictions.length; i < len && !isValid; i++) {
+                    isValid = restrictions[i].restrictionType === RestrictionType.REQUIRE_CONSENT && gvlVendorKey === "purposes" || restrictions[i].restrictionType === RestrictionType.REQUIRE_LI && gvlVendorKey === "legIntPurposes";
+                  }
+                  if (!isValid) {
+                    vector.unset(vendorId);
+                  }
+                }
+              } else {
+                vector.unset(vendorId);
+              }
+            }
+          }
+        }
+      });
+    });
+    tcModel.vendorsDisclosed.set(gvl.vendors);
+    return tcModel;
+  }
+]);
+class Json {
+  static absCall(url, body, sendCookies, timeout) {
+    return new Promise((resolve, reject) => {
+      const req = new XMLHttpRequest();
+      const onLoad = () => {
+        if (req.readyState == XMLHttpRequest.DONE) {
+          if (req.status >= 200 && req.status < 300) {
+            let response = req.response;
+            if (typeof response === "string") {
+              try {
+                response = JSON.parse(response);
+              } catch (e) {
+              }
+            }
+            resolve(response);
+          } else {
+            reject(new Error(`HTTP Status: ${req.status} response type: ${req.responseType}`));
+          }
+        }
+      };
+      const onError = () => {
+        reject(new Error("error"));
+      };
+      const onAbort = () => {
+        reject(new Error("aborted"));
+      };
+      const onTimeout = () => {
+        reject(new Error("Timeout " + timeout + "ms " + url));
+      };
+      req.withCredentials = sendCookies;
+      req.addEventListener("load", onLoad);
+      req.addEventListener("error", onError);
+      req.addEventListener("abort", onAbort);
+      if (body === null) {
+        req.open("GET", url, true);
+      } else {
+        req.open("POST", url, true);
+      }
+      req.responseType = "json";
+      req.timeout = timeout;
+      req.ontimeout = onTimeout;
+      req.send(body);
+    });
+  }
+  /**
+   * @static
+   * @param {string} url - full path to POST to
+   * @param {object} body - JSON object to post
+   * @param {boolean} sendCookies - Whether or not to send the XMLHttpRequest with credentials or not
+   * @param {number} [timeout] - optional timeout in milliseconds
+   * @return {Promise<object>} - if the server responds the response will be returned here
+   */
+  static post(url, body, sendCookies = false, timeout = 0) {
+    return this.absCall(url, JSON.stringify(body), sendCookies, timeout);
+  }
+  /**
+   * @static
+   * @param {string} url - full path to the json
+   * @param {boolean} sendCookies - Whether or not to send the XMLHttpRequest with credentials or not
+   * @param {number} [timeout] - optional timeout in milliseconds
+   * @return {Promise<object>} - resolves with parsed JSON
+   */
+  static fetch(url, sendCookies = false, timeout = 0) {
+    return this.absCall(url, null, sendCookies, timeout);
+  }
+}
+const _GVL = class _GVL2 extends Cloneable {
+  /**
+   * @param {VersionOrVendorList} [versionOrVendorList] - can be either a
+   * [[VendorList]] object or a version number represented as a string or
+   * number to download.  If nothing is passed the latest version of the GVL
+   * will be loaded
+   */
+  constructor(versionOrVendorList) {
+    super();
+    __publicField(this, "readyPromise");
+    __publicField(this, "gvlSpecificationVersion");
+    __publicField(this, "vendorListVersion");
+    __publicField(this, "tcfPolicyVersion");
+    __publicField(this, "lastUpdated");
+    __publicField(this, "purposes");
+    __publicField(this, "specialPurposes");
+    __publicField(this, "features");
+    __publicField(this, "specialFeatures");
+    __publicField(this, "isReady_", false);
+    __publicField(this, "vendors_");
+    __publicField(this, "vendorIds");
+    __publicField(this, "fullVendorList");
+    __publicField(this, "byPurposeVendorMap");
+    __publicField(this, "bySpecialPurposeVendorMap");
+    __publicField(this, "byFeatureVendorMap");
+    __publicField(this, "bySpecialFeatureVendorMap");
+    __publicField(this, "stacks");
+    __publicField(this, "dataCategories");
+    __publicField(this, "lang_");
+    __publicField(this, "cacheLang_");
+    __publicField(this, "isLatest", false);
+    let url = _GVL2.baseUrl;
+    this.lang_ = _GVL2.DEFAULT_LANGUAGE;
+    this.cacheLang_ = _GVL2.DEFAULT_LANGUAGE;
+    if (this.isVendorList(versionOrVendorList)) {
+      this.populate(versionOrVendorList);
+      this.readyPromise = Promise.resolve();
+    } else {
+      if (!url) {
+        throw new GVLError("must specify GVL.baseUrl before loading GVL json");
+      }
+      if (versionOrVendorList > 0) {
+        const version = versionOrVendorList;
+        if (_GVL2.CACHE.has(version)) {
+          this.populate(_GVL2.CACHE.get(version));
+          this.readyPromise = Promise.resolve();
+        } else {
+          url += _GVL2.versionedFilename.replace("[VERSION]", String(version));
+          this.readyPromise = this.fetchJson(url);
+        }
+      } else {
+        if (_GVL2.CACHE.has(_GVL2.LATEST_CACHE_KEY)) {
+          this.populate(_GVL2.CACHE.get(_GVL2.LATEST_CACHE_KEY));
+          this.readyPromise = Promise.resolve();
+        } else {
+          this.isLatest = true;
+          this.readyPromise = this.fetchJson(url + _GVL2.latestFilename);
+        }
+      }
+    }
+  }
+  /**
+   * baseUrl - Entities using the vendor-list.json are required by the iab to
+   * host their own copy of it to reduce the load on the iab's infrastructure
+   * so a 'base' url must be set to be put together with the versioning scheme
+   * of the filenames.
+   *
+   * @static
+   * @param {string} url - the base url to load the vendor-list.json from.  This is
+   * broken out from the filename because it follows a different scheme for
+   * latest file vs versioned files.
+   *
+   * @throws {GVLError} - If the url is http[s]://vendorlist.consensu.org/...
+   * this will throw an error.  IAB Europe requires that that CMPs and Vendors
+   * cache their own copies of the GVL to minimize load on their
+   * infrastructure.  For more information regarding caching of the
+   * vendor-list.json, please see [the TCF documentation on 'Caching the Global
+   * Vendor List'
+   * ](https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20Consent%20string%20and%20vendor%20list%20formats%20v2.md#caching-the-global-vendor-list)
+   */
+  static set baseUrl(url) {
+    const notValid = /^https?:\/\/vendorlist\.consensu\.org\//;
+    if (notValid.test(url)) {
+      throw new GVLError("Invalid baseUrl!  You may not pull directly from vendorlist.consensu.org and must provide your own cache");
+    }
+    if (url.length > 0 && url[url.length - 1] !== "/") {
+      url += "/";
+    }
+    this.baseUrl_ = url;
+  }
+  /**
+   * baseUrl - Entities using the vendor-list.json are required by the iab to
+   * host their own copy of it to reduce the load on the iab's infrastructure
+   * so a 'base' url must be set to be put together with the versioning scheme
+   * of the filenames.
+   *
+   * @static
+   * @return {string} - returns the previously set baseUrl, the default is
+   * `undefined`
+   */
+  static get baseUrl() {
+    return this.baseUrl_;
+  }
+  /**
+   * emptyLanguageCache
+   *
+   * @param {string} [lang] - Optional language code to remove from
+   * the cache.  Should be one of the languages in GVL.consentLanguages set.
+   * If not then the whole cache will be deleted.
+   * @return {boolean} - true if anything was deleted from the cache
+   */
+  static emptyLanguageCache(lang) {
+    let result = false;
+    if (lang == null && _GVL2.LANGUAGE_CACHE.size > 0) {
+      _GVL2.LANGUAGE_CACHE = /* @__PURE__ */ new Map();
+      result = true;
+    } else if (typeof lang === "string" && this.consentLanguages.has(lang.toUpperCase())) {
+      _GVL2.LANGUAGE_CACHE.delete(lang.toUpperCase());
+      result = true;
+    }
+    return result;
+  }
+  /**
+   * emptyCache
+   *
+   * @param {number} [vendorListVersion] - version of the vendor list to delete
+   * from the cache.  If none is specified then the whole cache is deleted.
+   * @return {boolean} - true if anything was deleted from the cache
+   */
+  static emptyCache(vendorListVersion) {
+    let retr = false;
+    if (Number.isInteger(vendorListVersion) && vendorListVersion >= 0) {
+      _GVL2.CACHE.delete(vendorListVersion);
+      retr = true;
+    } else if (vendorListVersion === void 0) {
+      _GVL2.CACHE = /* @__PURE__ */ new Map();
+      retr = true;
+    }
+    return retr;
+  }
+  cacheLanguage() {
+    if (!_GVL2.LANGUAGE_CACHE.has(this.cacheLang_)) {
+      _GVL2.LANGUAGE_CACHE.set(this.cacheLang_, {
+        purposes: this.purposes,
+        specialPurposes: this.specialPurposes,
+        features: this.features,
+        specialFeatures: this.specialFeatures,
+        stacks: this.stacks,
+        dataCategories: this.dataCategories
+      });
+    }
+  }
+  async fetchJson(url) {
+    try {
+      this.populate(await Json.fetch(url));
+    } catch (err) {
+      throw new GVLError(err.message);
+    }
+  }
+  /**
+   * getJson - Method for getting the JSON that was downloaded to created this
+   * `GVL` object
+   *
+   * @return {VendorList} - The basic JSON structure without the extra
+   * functionality and methods of this class.
+   */
+  getJson() {
+    return JSON.parse(JSON.stringify({
+      gvlSpecificationVersion: this.gvlSpecificationVersion,
+      vendorListVersion: this.vendorListVersion,
+      tcfPolicyVersion: this.tcfPolicyVersion,
+      lastUpdated: this.lastUpdated,
+      purposes: this.purposes,
+      specialPurposes: this.specialPurposes,
+      features: this.features,
+      specialFeatures: this.specialFeatures,
+      stacks: this.stacks,
+      dataCategories: this.dataCategories,
+      vendors: this.fullVendorList
+    }));
+  }
+  /**
+   * changeLanguage - retrieves the purpose language translation and sets the
+   * internal language variable
+   *
+   * @param {string} lang - language code to change language to
+   * @return {Promise<void | GVLError>} - returns the `readyPromise` and
+   * resolves when this GVL is populated with the data from the language file.
+   */
+  async changeLanguage(lang) {
+    let parsedLanguage = lang;
+    try {
+      parsedLanguage = _GVL2.consentLanguages.parseLanguage(lang);
+    } catch (e) {
+      throw new GVLError("Error during parsing the language: " + e.message);
+    }
+    const cacheLang = lang.toUpperCase();
+    if (parsedLanguage.toLowerCase() === _GVL2.DEFAULT_LANGUAGE.toLowerCase() && !_GVL2.LANGUAGE_CACHE.has(cacheLang)) {
+      return;
+    }
+    if (parsedLanguage !== this.lang_) {
+      this.lang_ = parsedLanguage;
+      if (_GVL2.LANGUAGE_CACHE.has(cacheLang)) {
+        const cached = _GVL2.LANGUAGE_CACHE.get(cacheLang);
+        for (const prop in cached) {
+          if (cached.hasOwnProperty(prop)) {
+            this[prop] = cached[prop];
+          }
+        }
+      } else {
+        const url = _GVL2.baseUrl + _GVL2.languageFilename.replace("[LANG]", this.lang_.toLowerCase());
+        try {
+          await this.fetchJson(url);
+          this.cacheLang_ = cacheLang;
+          this.cacheLanguage();
+        } catch (err) {
+          throw new GVLError("unable to load language: " + err.message);
+        }
+      }
+    }
+  }
+  get language() {
+    return this.lang_;
+  }
+  isVendorList(gvlObject) {
+    return gvlObject !== void 0 && gvlObject.vendors !== void 0;
+  }
+  populate(gvlObject) {
+    this.purposes = gvlObject.purposes;
+    this.specialPurposes = gvlObject.specialPurposes;
+    this.features = gvlObject.features;
+    this.specialFeatures = gvlObject.specialFeatures;
+    this.stacks = gvlObject.stacks;
+    this.dataCategories = gvlObject.dataCategories;
+    if (this.isVendorList(gvlObject)) {
+      this.gvlSpecificationVersion = gvlObject.gvlSpecificationVersion;
+      this.tcfPolicyVersion = gvlObject.tcfPolicyVersion;
+      this.vendorListVersion = gvlObject.vendorListVersion;
+      this.lastUpdated = gvlObject.lastUpdated;
+      if (typeof this.lastUpdated === "string") {
+        this.lastUpdated = new Date(this.lastUpdated);
+      }
+      this.vendors_ = gvlObject.vendors;
+      this.fullVendorList = gvlObject.vendors;
+      this.mapVendors();
+      this.isReady_ = true;
+      if (this.isLatest) {
+        _GVL2.CACHE.set(_GVL2.LATEST_CACHE_KEY, this.getJson());
+      }
+      if (!_GVL2.CACHE.has(this.vendorListVersion)) {
+        _GVL2.CACHE.set(this.vendorListVersion, this.getJson());
+      }
+    }
+    this.cacheLanguage();
+  }
+  mapVendors(vendorIds) {
+    this.byPurposeVendorMap = {};
+    this.bySpecialPurposeVendorMap = {};
+    this.byFeatureVendorMap = {};
+    this.bySpecialFeatureVendorMap = {};
+    Object.keys(this.purposes).forEach((purposeId) => {
+      this.byPurposeVendorMap[purposeId] = {
+        legInt: /* @__PURE__ */ new Set(),
+        consent: /* @__PURE__ */ new Set(),
+        flexible: /* @__PURE__ */ new Set()
+      };
+    });
+    Object.keys(this.specialPurposes).forEach((purposeId) => {
+      this.bySpecialPurposeVendorMap[purposeId] = /* @__PURE__ */ new Set();
+    });
+    Object.keys(this.features).forEach((featureId) => {
+      this.byFeatureVendorMap[featureId] = /* @__PURE__ */ new Set();
+    });
+    Object.keys(this.specialFeatures).forEach((featureId) => {
+      this.bySpecialFeatureVendorMap[featureId] = /* @__PURE__ */ new Set();
+    });
+    if (!Array.isArray(vendorIds)) {
+      vendorIds = Object.keys(this.fullVendorList).map((vId) => +vId);
+    }
+    this.vendorIds = new Set(vendorIds);
+    this.vendors_ = vendorIds.reduce((vendors, vendorId) => {
+      const vendor = this.vendors_[String(vendorId)];
+      if (vendor && vendor.deletedDate === void 0) {
+        vendor.purposes.forEach((purposeId) => {
+          const purpGroup = this.byPurposeVendorMap[String(purposeId)];
+          purpGroup.consent.add(vendorId);
+        });
+        vendor.specialPurposes.forEach((purposeId) => {
+          this.bySpecialPurposeVendorMap[String(purposeId)].add(vendorId);
+        });
+        vendor.legIntPurposes.forEach((purposeId) => {
+          this.byPurposeVendorMap[String(purposeId)].legInt.add(vendorId);
+        });
+        if (vendor.flexiblePurposes) {
+          vendor.flexiblePurposes.forEach((purposeId) => {
+            this.byPurposeVendorMap[String(purposeId)].flexible.add(vendorId);
+          });
+        }
+        vendor.features.forEach((featureId) => {
+          this.byFeatureVendorMap[String(featureId)].add(vendorId);
+        });
+        vendor.specialFeatures.forEach((featureId) => {
+          this.bySpecialFeatureVendorMap[String(featureId)].add(vendorId);
+        });
+        vendors[vendorId] = vendor;
+      }
+      return vendors;
+    }, {});
+  }
+  getFilteredVendors(purposeOrFeature, id, subType, special) {
+    const properPurposeOrFeature = purposeOrFeature.charAt(0).toUpperCase() + purposeOrFeature.slice(1);
+    let vendorSet;
+    const retr = {};
+    if (purposeOrFeature === "purpose" && subType) {
+      vendorSet = this["by" + properPurposeOrFeature + "VendorMap"][String(id)][subType];
+    } else {
+      vendorSet = this["by" + (special ? "Special" : "") + properPurposeOrFeature + "VendorMap"][String(id)];
+    }
+    vendorSet.forEach((vendorId) => {
+      retr[String(vendorId)] = this.vendors[String(vendorId)];
+    });
+    return retr;
+  }
+  /**
+   * getVendorsWithConsentPurpose
+   *
+   * @param {number} purposeId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the consent purpose id
+   */
+  getVendorsWithConsentPurpose(purposeId) {
+    return this.getFilteredVendors("purpose", purposeId, "consent");
+  }
+  /**
+   * getVendorsWithLegIntPurpose
+   *
+   * @param {number} purposeId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the legInt (Legitimate Interest) purpose id
+   */
+  getVendorsWithLegIntPurpose(purposeId) {
+    return this.getFilteredVendors("purpose", purposeId, "legInt");
+  }
+  /**
+   * getVendorsWithFlexiblePurpose
+   *
+   * @param {number} purposeId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the flexible purpose id
+   */
+  getVendorsWithFlexiblePurpose(purposeId) {
+    return this.getFilteredVendors("purpose", purposeId, "flexible");
+  }
+  /**
+   * getVendorsWithSpecialPurpose
+   *
+   * @param {number} specialPurposeId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the special purpose id
+   */
+  getVendorsWithSpecialPurpose(specialPurposeId) {
+    return this.getFilteredVendors("purpose", specialPurposeId, void 0, true);
+  }
+  /**
+   * getVendorsWithFeature
+   *
+   * @param {number} featureId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the feature id
+   */
+  getVendorsWithFeature(featureId) {
+    return this.getFilteredVendors("feature", featureId);
+  }
+  /**
+   * getVendorsWithSpecialFeature
+   *
+   * @param {number} specialFeatureId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the special feature id
+   */
+  getVendorsWithSpecialFeature(specialFeatureId) {
+    return this.getFilteredVendors("feature", specialFeatureId, void 0, true);
+  }
+  /**
+   * vendors
+   *
+   * @return {IntMap<Vendor>} - the list of vendors as it would on the JSON file
+   * except if `narrowVendorsTo` was called, it would be that narrowed list
+   */
+  get vendors() {
+    return this.vendors_;
+  }
+  /**
+   * narrowVendorsTo - narrows vendors represented in this GVL to the list of ids passed in
+   *
+   * @param {number[]} vendorIds - list of ids to narrow this GVL to
+   * @return {void}
+   */
+  narrowVendorsTo(vendorIds) {
+    this.mapVendors(vendorIds);
+  }
+  /**
+   * isReady - Whether or not this instance is ready to be used.  This will be
+   * immediately and synchronously true if a vendorlist object is passed into
+   * the constructor or once the JSON vendorllist is retrieved.
+   *
+   * @return {boolean} whether or not the instance is ready to be interacted
+   * with and all the data is populated
+   */
+  get isReady() {
+    return this.isReady_;
+  }
+  /**
+   * clone - overrides base `clone()` method since GVL is a special class that
+   * represents a JSON structure with some additional functionality.
+   *
+   * @return {GVL}
+   */
+  clone() {
+    const result = new _GVL2(this.getJson());
+    if (this.lang_ !== _GVL2.DEFAULT_LANGUAGE) {
+      result.changeLanguage(this.lang_);
+    }
+    return result;
+  }
+  static isInstanceOf(questionableInstance) {
+    const isSo = typeof questionableInstance === "object";
+    return isSo && typeof questionableInstance.narrowVendorsTo === "function";
+  }
+};
+__publicField(_GVL, "LANGUAGE_CACHE", /* @__PURE__ */ new Map());
+__publicField(_GVL, "CACHE", /* @__PURE__ */ new Map());
+__publicField(_GVL, "LATEST_CACHE_KEY", 0);
+__publicField(_GVL, "DEFAULT_LANGUAGE", "EN");
+__publicField(_GVL, "consentLanguages", new ConsentLanguages());
+__publicField(_GVL, "baseUrl_");
+__publicField(_GVL, "latestFilename", "vendor-list.json");
+__publicField(_GVL, "versionedFilename", "archives/vendor-list-v[VERSION].json");
+__publicField(_GVL, "languageFilename", "purposes-[LANG].json");
+let GVL = _GVL;
+class TCModel extends Cloneable {
+  /**
+   * Constructs the TCModel. Passing a [[GVL]] is optional when constructing
+   * as this TCModel may be constructed from decoding an existing encoded
+   * TCString.
+   *
+   * @param {GVL} [gvl]
+   */
+  constructor(gvl) {
+    super();
+    __publicField(this, "isServiceSpecific_", false);
+    __publicField(this, "supportOOB_", true);
+    __publicField(this, "useNonStandardTexts_", false);
+    __publicField(this, "purposeOneTreatment_", false);
+    __publicField(this, "publisherCountryCode_", "AA");
+    __publicField(this, "version_", 2);
+    __publicField(this, "consentScreen_", 0);
+    __publicField(this, "policyVersion_", 4);
+    __publicField(this, "consentLanguage_", "EN");
+    __publicField(this, "cmpId_", 0);
+    __publicField(this, "cmpVersion_", 0);
+    __publicField(this, "vendorListVersion_", 0);
+    __publicField(this, "numCustomPurposes_", 0);
+    __publicField(this, "gvl_");
+    __publicField(this, "created");
+    __publicField(this, "lastUpdated");
+    __publicField(this, "specialFeatureOptins", new Vector());
+    __publicField(this, "purposeConsents", new Vector());
+    __publicField(this, "purposeLegitimateInterests", new Vector());
+    __publicField(this, "publisherConsents", new Vector());
+    __publicField(this, "publisherLegitimateInterests", new Vector());
+    __publicField(this, "publisherCustomConsents", new Vector());
+    __publicField(this, "publisherCustomLegitimateInterests", new Vector());
+    __publicField(this, "customPurposes");
+    __publicField(this, "vendorConsents", new Vector());
+    __publicField(this, "vendorLegitimateInterests", new Vector());
+    __publicField(this, "vendorsDisclosed", new Vector());
+    __publicField(this, "vendorsAllowed", new Vector());
+    __publicField(this, "publisherRestrictions", new PurposeRestrictionVector());
+    if (gvl) {
+      this.gvl = gvl;
+    }
+    this.updated();
+  }
+  /**
+   * sets the [[GVL]] with side effects of also setting the `vendorListVersion`, `policyVersion`, and `consentLanguage`
+   * @param {GVL} gvl
+   */
+  set gvl(gvl) {
+    if (!GVL.isInstanceOf(gvl)) {
+      gvl = new GVL(gvl);
+    }
+    this.gvl_ = gvl;
+    this.publisherRestrictions.gvl = gvl;
+  }
+  /**
+   * @return {GVL} the gvl instance set on this TCModel instance
+   */
+  get gvl() {
+    return this.gvl_;
+  }
+  /**
+   * @param {number} integer - A unique ID will be assigned to each Consent
+   * Manager Provider (CMP) from the iab.
+   *
+   * @throws {TCModelError} if the value is not an integer greater than 1 as those are not valid.
+   */
+  set cmpId(integer) {
+    integer = Number(integer);
+    if (Number.isInteger(integer) && integer > 1) {
+      this.cmpId_ = integer;
+    } else {
+      throw new TCModelError("cmpId", integer);
+    }
+  }
+  get cmpId() {
+    return this.cmpId_;
+  }
+  /**
+   * Each change to an operating CMP should receive a
+   * new version number, for logging proof of consent. CmpVersion defined by
+   * each CMP.
+   *
+   * @param {number} integer
+   *
+   * @throws {TCModelError} if the value is not an integer greater than 1 as those are not valid.
+   */
+  set cmpVersion(integer) {
+    integer = Number(integer);
+    if (Number.isInteger(integer) && integer > -1) {
+      this.cmpVersion_ = integer;
+    } else {
+      throw new TCModelError("cmpVersion", integer);
+    }
+  }
+  get cmpVersion() {
+    return this.cmpVersion_;
+  }
+  /**
+   * The screen number is CMP and CmpVersion
+   * specific, and is for logging proof of consent.(For example, a CMP could
+   * keep records so that a publisher can request information about the context
+   * in which consent was gathered.)
+   *
+   * @param {number} integer
+   *
+   * @throws {TCModelError} if the value is not an integer greater than 0 as those are not valid.
+   */
+  set consentScreen(integer) {
+    integer = Number(integer);
+    if (Number.isInteger(integer) && integer > -1) {
+      this.consentScreen_ = integer;
+    } else {
+      throw new TCModelError("consentScreen", integer);
+    }
+  }
+  get consentScreen() {
+    return this.consentScreen_;
+  }
+  /**
+   * @param {string} lang - [two-letter ISO 639-1 language
+   * code](http://www.loc.gov/standards/iso639-2/php/code_list.php) in which
+   * the CMP UI was presented
+   *
+   * @throws {TCModelError} if the value is not a length-2 string of alpha characters
+   */
+  set consentLanguage(lang) {
+    this.consentLanguage_ = lang;
+  }
+  get consentLanguage() {
+    return this.consentLanguage_;
+  }
+  /**
+   * @param {string} countryCode - [two-letter ISO 3166-1 alpha-2 country
+   * code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the publisher,
+   * determined by the CMP-settings of the publisher.
+   *
+   * @throws {TCModelError} if the value is not a length-2 string of alpha characters
+   */
+  set publisherCountryCode(countryCode) {
+    if (/^([A-z]){2}$/.test(countryCode)) {
+      this.publisherCountryCode_ = countryCode.toUpperCase();
+    } else {
+      throw new TCModelError("publisherCountryCode", countryCode);
+    }
+  }
+  get publisherCountryCode() {
+    return this.publisherCountryCode_;
+  }
+  /**
+   * Version of the GVL used to create this TCModel. Global
+   * Vendor List versions will be released periodically.
+   *
+   * @param {number} integer
+   *
+   * @throws {TCModelError} if the value is not an integer greater than 0 as those are not valid.
+   */
+  set vendorListVersion(integer) {
+    integer = Number(integer) >> 0;
+    if (integer < 0) {
+      throw new TCModelError("vendorListVersion", integer);
+    } else {
+      this.vendorListVersion_ = integer;
+    }
+  }
+  get vendorListVersion() {
+    if (this.gvl) {
+      return this.gvl.vendorListVersion;
+    } else {
+      return this.vendorListVersion_;
+    }
+  }
+  /**
+   * From the corresponding field in the GVL that was
+   * used for obtaining consent. A new policy version invalidates existing
+   * strings and requires CMPs to re-establish transparency and consent from
+   * users.
+   *
+   * If a TCF policy version number is different from the one from the latest
+   * GVL, the CMP must re-establish transparency and consent.
+   *
+   * @param {number} num - You do not need to set this.  This comes
+   * directly from the [[GVL]].
+   *
+   */
+  set policyVersion(num) {
+    this.policyVersion_ = parseInt(num, 10);
+    if (this.policyVersion_ < 0) {
+      throw new TCModelError("policyVersion", num);
+    }
+  }
+  get policyVersion() {
+    if (this.gvl) {
+      return this.gvl.tcfPolicyVersion;
+    } else {
+      return this.policyVersion_;
+    }
+  }
+  set version(num) {
+    this.version_ = parseInt(num, 10);
+  }
+  get version() {
+    return this.version_;
+  }
+  /**
+   * Whether the signals encoded in this TC String were from site-specific
+   * storage `true` versus ‘global’ consensu.org shared storage `false`. A
+   * string intended to be stored in global/shared scope but the CMP is unable
+   * to store due to a user agent not accepting third-party cookies would be
+   * considered site-specific `true`.
+   *
+   * @param {boolean} bool - value to set. Some changes to other fields in this
+   * model will automatically change this value like adding publisher
+   * restrictions.
+   */
+  set isServiceSpecific(bool) {
+    this.isServiceSpecific_ = bool;
+  }
+  get isServiceSpecific() {
+    return this.isServiceSpecific_;
+  }
+  /**
+   * Non-standard stacks means that a CMP is using publisher-customized stack
+   * descriptions. Stacks (in terms of purposes in a stack) are pre-set by the
+   * IAB. As are titles. Descriptions are pre-set, but publishers can customize
+   * them. If they do, they need to set this bit to indicate that they've
+   * customized descriptions.
+   *
+   * @param {boolean} bool - value to set
+   */
+  set useNonStandardTexts(bool) {
+    this.useNonStandardTexts_ = bool;
+  }
+  get useNonStandardTexts() {
+    return this.useNonStandardTexts_;
+  }
+  /**
+   * Whether or not this publisher supports OOB signaling.  On Global TC String
+   * OOB Vendors Disclosed will be included if the publish wishes to no allow
+   * these vendors they should set this to false.
+   * @param {boolean} bool - value to set
+   */
+  set supportOOB(bool) {
+    this.supportOOB_ = bool;
+  }
+  get supportOOB() {
+    return this.supportOOB_;
+  }
+  /**
+   * `false` There is no special Purpose 1 status.
+   * Purpose 1 was disclosed normally (consent) as expected by Policy.  `true`
+   * Purpose 1 not disclosed at all. CMPs use PublisherCC to indicate the
+   * publisher’s country of establishment to help Vendors determine whether the
+   * vendor requires Purpose 1 consent. In global scope TC strings, this field
+   * must always have a value of `false`. When a CMP encounters a global scope
+   * string with `purposeOneTreatment=true` then that string should be
+   * considered invalid and the CMP must re-establish transparency and consent.
+   *
+   * @param {boolean} bool
+   */
+  set purposeOneTreatment(bool) {
+    this.purposeOneTreatment_ = bool;
+  }
+  get purposeOneTreatment() {
+    return this.purposeOneTreatment_;
+  }
+  /**
+   * setAllVendorConsents - sets all vendors on the GVL Consent (true)
+   *
+   * @return {void}
+   */
+  setAllVendorConsents() {
+    this.vendorConsents.set(this.gvl.vendors);
+  }
+  /**
+   * unsetAllVendorConsents - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */
+  unsetAllVendorConsents() {
+    this.vendorConsents.empty();
+  }
+  /**
+   * setAllVendorsDisclosed - sets all vendors on the GVL Vendors Disclosed (true)
+   *
+   * @return {void}
+   */
+  setAllVendorsDisclosed() {
+    this.vendorsDisclosed.set(this.gvl.vendors);
+  }
+  /**
+   * unsetAllVendorsDisclosed - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */
+  unsetAllVendorsDisclosed() {
+    this.vendorsDisclosed.empty();
+  }
+  /**
+   * setAllVendorsAllowed - sets all vendors on the GVL Consent (true)
+   *
+   * @return {void}
+   */
+  setAllVendorsAllowed() {
+    this.vendorsAllowed.set(this.gvl.vendors);
+  }
+  /**
+   * unsetAllVendorsAllowed - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */
+  unsetAllVendorsAllowed() {
+    this.vendorsAllowed.empty();
+  }
+  /**
+   * setAllVendorLegitimateInterests - sets all vendors on the GVL LegitimateInterests (true)
+   *
+   * @return {void}
+   */
+  setAllVendorLegitimateInterests() {
+    this.vendorLegitimateInterests.set(this.gvl.vendors);
+  }
+  /**
+   * unsetAllVendorLegitimateInterests - unsets all vendors on the GVL LegitimateInterests (false)
+   *
+   * @return {void}
+   */
+  unsetAllVendorLegitimateInterests() {
+    this.vendorLegitimateInterests.empty();
+  }
+  /**
+   * setAllPurposeConsents - sets all purposes on the GVL Consent (true)
+   *
+   * @return {void}
+   */
+  setAllPurposeConsents() {
+    this.purposeConsents.set(this.gvl.purposes);
+  }
+  /**
+   * unsetAllPurposeConsents - unsets all purposes on the GVL Consent (false)
+   *
+   * @return {void}
+   */
+  unsetAllPurposeConsents() {
+    this.purposeConsents.empty();
+  }
+  /**
+   * setAllPurposeLegitimateInterests - sets all purposes on the GVL LI Transparency (true)
+   *
+   * @return {void}
+   */
+  setAllPurposeLegitimateInterests() {
+    this.purposeLegitimateInterests.set(this.gvl.purposes);
+  }
+  /**
+   * unsetAllPurposeLegitimateInterests - unsets all purposes on the GVL LI Transparency (false)
+   *
+   * @return {void}
+   */
+  unsetAllPurposeLegitimateInterests() {
+    this.purposeLegitimateInterests.empty();
+  }
+  /**
+   * setAllSpecialFeatureOptins - sets all special featuresOptins on the GVL (true)
+   *
+   * @return {void}
+   */
+  setAllSpecialFeatureOptins() {
+    this.specialFeatureOptins.set(this.gvl.specialFeatures);
+  }
+  /**
+   * unsetAllSpecialFeatureOptins - unsets all special featuresOptins on the GVL (true)
+   *
+   * @return {void}
+   */
+  unsetAllSpecialFeatureOptins() {
+    this.specialFeatureOptins.empty();
+  }
+  setAll() {
+    this.setAllVendorConsents();
+    this.setAllPurposeLegitimateInterests();
+    this.setAllSpecialFeatureOptins();
+    this.setAllPurposeConsents();
+    this.setAllVendorLegitimateInterests();
+  }
+  unsetAll() {
+    this.unsetAllVendorConsents();
+    this.unsetAllPurposeLegitimateInterests();
+    this.unsetAllSpecialFeatureOptins();
+    this.unsetAllPurposeConsents();
+    this.unsetAllVendorLegitimateInterests();
+  }
+  get numCustomPurposes() {
+    let len = this.numCustomPurposes_;
+    if (typeof this.customPurposes === "object") {
+      const purposeIds = Object.keys(this.customPurposes).sort((a, b) => Number(a) - Number(b));
+      len = parseInt(purposeIds.pop(), 10);
+    }
+    return len;
+  }
+  set numCustomPurposes(num) {
+    this.numCustomPurposes_ = parseInt(num, 10);
+    if (this.numCustomPurposes_ < 0) {
+      throw new TCModelError("numCustomPurposes", num);
+    }
+  }
+  /**
+   * updated - updates the created and lastUpdated dates with a 'now' day-level UTC timestamp
+   *
+   * @return {void}
+   */
+  updated() {
+    const date = /* @__PURE__ */ new Date();
+    const utcDate = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    this.created = utcDate;
+    this.lastUpdated = utcDate;
+  }
+}
+__publicField(TCModel, "consentLanguages", GVL.consentLanguages);
+class TCString {
+  /**
+   * encodes a model into a TCString
+   *
+   * @param {TCModel} tcModel - model to convert into encoded string
+   * @param {EncodingOptions} options - for encoding options other than default
+   * @return {string} - base64url encoded Transparency and Consent String
+   */
+  static encode(tcModel, options) {
+    let out = "";
+    let sequence;
+    tcModel = SemanticPreEncoder.process(tcModel, options);
+    if (Array.isArray(options == null ? void 0 : options.segments)) {
+      sequence = options.segments;
+    } else {
+      sequence = new SegmentSequence(tcModel, options)["" + tcModel.version];
+    }
+    sequence.forEach((segment, idx) => {
+      let dotMaybe = "";
+      if (idx < sequence.length - 1) {
+        dotMaybe = ".";
+      }
+      out += SegmentEncoder.encode(tcModel, segment) + dotMaybe;
+    });
+    return out;
+  }
+  /**
+   * Decodes a string into a TCModel
+   *
+   * @param {string} encodedTCString - base64url encoded Transparency and
+   * Consent String to decode - can also be a single or group of segments of
+   * the string
+   * @param {string} [tcModel] - model to enhance with the information.  If
+   * none is passed a new instance of TCModel will be created.
+   * @return {TCModel} - Returns populated TCModel
+   */
+  static decode(encodedTCString, tcModel) {
+    const segments = encodedTCString.split(".");
+    const len = segments.length;
+    if (!tcModel) {
+      tcModel = new TCModel();
+    }
+    for (let i = 0; i < len; i++) {
+      const segString = segments[i];
+      const firstChar = Base64Url.decode(segString.charAt(0));
+      const segTypeBits = firstChar.substr(0, BitLength.segmentType);
+      const segment = SegmentIDs.ID_TO_KEY[IntEncoder.decode(segTypeBits, BitLength.segmentType).toString()];
+      SegmentEncoder.decode(segString, tcModel, segment);
+    }
+    return tcModel;
+  }
+}
+const iabCustomCategories = {
+  permutiveAds: {
+    purposes: [2, 4, 8, 9],
+    iabVendors: [361],
+    customVendors: [],
+    specialFeatures: []
+  },
+  demographicAds: {
+    purposes: [3, 4, 7, 9, 10],
+    iabVendors: [],
+    customVendors: [],
+    specialFeatures: []
+  }
+};
+function isValidGdprValue(val) {
+  if (val === null) {
+    return true;
+  }
+  try {
+    TCString.decode(val);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isValidUspString(val) {
+  if (val === null) {
+    return true;
+  }
+  const regex = /^[1-9][YN-][YN-][YN-]$/;
+  return regex.test(val);
+}
+function validateRawConsentState(input) {
+  if (typeof input !== "object" || input === null) {
+    throw new Error("Invalid consent state object");
+  }
+  if (!isValidGdprValue(input.gdpr)) {
+    throw new Error("Invalid TC string provided");
+  }
+  if (!isValidUspString(input.ccpa)) {
+    throw new Error("Invalid USP string provided");
+  }
+  if (!["ccpa", "gdpr"].includes(input.activeLegislation)) {
+    throw new Error("Active legislation is required");
+  }
+  if (input.gdpr === void 0 && input.ccpa === void 0) {
+    throw new Error("Either GDPR or CCPA consent must be provided");
+  }
+  return true;
+}
+function validateIabConsentCategory(categoryName) {
+  if (!categoryName || categoryName in iabCustomCategories === false) {
+    throw new Error("Provided custom category identifier does not exist. Please check");
+  }
+}
+const legislation = {
+  CCPA: "ccpa",
+  GDPR: "gdpr"
+};
+function checkConsentFor(categoryName, consentState) {
+  validateIabConsentCategory(categoryName);
+  validateRawConsentState(consentState);
+  const { gdpr, ccpa, activeLegislation } = consentState;
+  const customCategory = iabCustomCategories[categoryName];
+  if (activeLegislation === legislation.CCPA) {
+    const userHasNotOptedOut = (ccpa == null ? void 0 : ccpa[2]) === "N";
+    return userHasNotOptedOut;
+  }
+  const decodedGdprConsent = TCString.decode(gdpr);
+  const { purposeConsents, vendorConsents, specialFeatureOptins } = decodedGdprConsent;
+  const requiredPurposesConsented = customCategory.purposes.every(
+    (requiredPurpose) => purposeConsents.has(requiredPurpose)
+  );
+  const requiredIabVendorsConsented = customCategory.iabVendors.every(
+    (requiredVendor) => vendorConsents.has(requiredVendor)
+  );
+  const requiredSpecialFeaturesConsented = customCategory.specialFeatures.every(
+    (requiredFeature) => specialFeatureOptins.has(requiredFeature)
+  );
+  return requiredPurposesConsented && requiredIabVendorsConsented && requiredSpecialFeaturesConsented;
+}
+function getParsedConsent(rawConsentState) {
+  const categoryNames = Object.keys(iabCustomCategories);
+  return categoryNames.reduce((parsedConsent, categoryName) => {
+    parsedConsent[categoryName] = checkConsentFor(categoryName, rawConsentState);
+    return parsedConsent;
+  }, {});
+}
+function updateFooterLinkCMP() {
+  const cookieLink = document.querySelector(
+    "[href='https://www.ft.com/preferences/manage-cookies']"
+  );
+  if (cookieLink) {
+    cookieLink.href = "#";
+    cookieLink.setAttribute("onclick", "window._sp_.gdpr.loadPrivacyManagerModal(827767);");
+    cookieLink.dataset.cmpLink = "updated";
+    return true;
+  } else {
+    console.warn("CMP Footer Link was not found and not updated");
+    return false;
+  }
+}
+const SOURCEPOINT_CONSENT_SOURCE = "sourcepoint-cmp";
+const SOURCEPOINT_FOW_SCOPE = "FTPINK";
+const CONSENT_COOKIE_NAME = "FTConsent";
+function getPayload(parsedConsent, { shouldUpdateConsentStore, formOfWordsId, cookieDomain }) {
+  const categoryNames = Object.keys(parsedConsent);
+  const data = categoryNames.reduce((payload, categoryName) => {
+    payload[categoryName] = {
+      onsite: {
+        status: parsedConsent[categoryName],
+        lbi: false,
+        source: SOURCEPOINT_CONSENT_SOURCE,
+        fow: formOfWordsId
+      }
+    };
+    return payload;
+  }, {});
+  if (!shouldUpdateConsentStore) {
+    return { data };
+  } else {
+    return {
+      setConsentCookie: true,
+      formOfWordsId,
+      consentSource: SOURCEPOINT_CONSENT_SOURCE,
+      cookieDomain,
+      data
+    };
+  }
+}
+async function saveConsent(consentEndpoint, payload) {
+  try {
+    const response = await fetch(consentEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload),
+      credentials: "include"
+    });
+    if (!response.ok) {
+      console.error("Unable to save consent preferences", response.status);
+    }
+  } catch (error) {
+    console.error("An error occurred while saving consent", error);
+  }
+}
+function consentReadyHandlerFn(props) {
+  const { userId, consentProxyHost, cookieDomain, formOfWordsId, useConsentStore } = props;
+  return async (legislation2, _, consentString, consentMeta) => {
+    const activeLegislation = consentMeta.applies ? legislation2 : "gdpr";
+    if (activeLegislation !== legislation2 || !consentString) {
+      return;
+    }
+    const parsedConsent = getParsedConsent({
+      activeLegislation,
+      gdpr: activeLegislation === "gdpr" ? consentString : null,
+      ccpa: activeLegislation === "ccpa" ? consentString : null
+    });
+    const consentHasChanged = hasConsentChanged(parsedConsent);
+    if (!consentHasChanged) {
+      return;
+    }
+    let consentEndpoint = `${consentProxyHost}/__consent/consent-record-cookie?cookieDomain=${cookieDomain}`;
+    const shouldUpdateConsentStore = !!userId && useConsentStore;
+    if (shouldUpdateConsentStore) {
+      consentEndpoint = `${consentProxyHost}/__consent/consent-record/${SOURCEPOINT_FOW_SCOPE}/${userId}`;
+    }
+    const payload = getPayload(parsedConsent, {
+      formOfWordsId,
+      cookieDomain,
+      shouldUpdateConsentStore
+    });
+    await saveConsent(consentEndpoint, payload);
+    document.dispatchEvent(new CustomEvent("oCookieMessage.act", { bubbles: true }));
+  };
+}
+function hasConsentChanged(parsedConsent) {
+  const categories = Object.keys(parsedConsent);
+  const previousConsent = getConsentCookieValue();
+  return categories.some((category) => {
+    const adaptedCategoryName = `${category.toLowerCase()}Onsite`;
+    return parsedConsent[category] !== previousConsent[adaptedCategoryName];
+  });
+}
+function getConsentCookieValue() {
+  const cookies = Object.fromEntries(
+    document.cookie.split("; ").map((cookie) => cookie.split("="))
+  );
+  const encodedValue = cookies[CONSENT_COOKIE_NAME];
+  if (!encodedValue)
+    return {};
+  const decodedValue = decodeURIComponent(encodedValue);
+  return Object.fromEntries(
+    decodedValue.split(",").map((consent) => {
+      const [category, value] = consent.split(":");
+      const booleanConsent = [category, value === "on" ? true : false];
+      return booleanConsent;
+    })
+  );
+}
+const SOURCEPOINT_FOW_ID = "sourcepointCmp/VngD.XycZut.595cp9fWdp5XYP9vlFvk";
+const FT_COOKIE_DOMAIN = ".ft.com";
+const FT_CONSENT_PROXY_HOST = "https://consent.ft.com";
+function createContentScript(content) {
+  const s = document.createElement("script");
+  s.innerHTML = content;
+  return s;
+}
+function createSourceScript(src) {
+  const s = document.createElement("script");
+  s.src = src;
+  return s;
+}
+function getCmpScripts(config) {
+  const fragment = document.createDocumentFragment();
+  fragment.appendChild(createContentScript(scriptContent.tcfStub));
+  fragment.appendChild(createContentScript(scriptContent.uspStub));
+  fragment.appendChild(createContentScript(scriptContent.getSPConfig(config)));
+  fragment.appendChild(createSourceScript(scriptSources.cmpFrames));
+  return fragment;
+}
+async function initSourcepointCmp({
+  propertyConfig = properties.FT_DOTCOM_PROD,
+  userId,
+  useFTSession = true,
+  consentProxyHost = FT_CONSENT_PROXY_HOST,
+  cookieDomain = FT_COOKIE_DOMAIN,
+  formOfWordsId = SOURCEPOINT_FOW_ID,
+  useConsentStore = true
+}) {
+  let maybeUserId = userId;
+  if (!maybeUserId && useFTSession) {
+    try {
+      const response = await getUuid();
+      maybeUserId = response == null ? void 0 : response.uuid;
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  if (!(propertyConfig == null ? void 0 : propertyConfig.accountId)) {
+    throw new Error("Please pass a valid property config");
+  }
+  if (maybeUserId) {
+    propertyConfig.authId = maybeUserId;
+  }
+  const scripts = getCmpScripts(propertyConfig);
+  document.head.appendChild(scripts);
+  window._sp_queue.push(() => {
+    window._sp_.addEventListener(
+      "onConsentReady",
+      consentReadyHandlerFn({
+        userId: maybeUserId,
+        consentProxyHost,
+        cookieDomain,
+        formOfWordsId,
+        useConsentStore
+      })
+    );
+  });
+}
+exports.getCmpScripts = getCmpScripts;
+exports.initSourcepointCmp = initSourcepointCmp;
+exports.updateFooterLinkCMP = updateFooterLinkCMP;