@brndts/brndts-ads 1.1.1 → 1.1.2

package/dist/index.mjs

@@ -420,6 +420,14 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = function(obj, key, value2) {
+    return key in obj ? __defProp(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: value2
+    }) : obj[key] = value2;
+};
 var __commonJS = function(cb, mod) {
     return function __require() {
         return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
@@ -474,6 +482,10 @@ var __toESM = function(mod, isNodeMode, target) {
         enumerable: true
     }) : target, mod);
 };
+var __publicField = function(obj, key, value2) {
+    __defNormalProp(obj, (typeof key === "undefined" ? "undefined" : _type_of(key)) !== "symbol" ? key + "" : key, value2);
+    return value2;
+};
 // node_modules/events/events.js
 var require_events = __commonJS({
     "node_modules/events/events.js": function(exports, module2) {
@@ -1051,7 +1063,7 @@ function isSyntheticEvent(wat) {
 function isInstanceOf(wat, base) {
     try {
         return _instanceof(wat, base);
-    } catch (_e) {
+    } catch (_e2) {
         return false;
     }
 }
@@ -18687,47 +18699,19 @@ function getGeneralInfo() {
 function _getGeneralInfo() {
     _getGeneralInfo = // src/Common/info.ts
     _async_to_generator(function() {
-        var info, ipInfo, error;
+        var info;
         return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    info = {};
-                    _state.label = 1;
-                case 1:
-                    _state.trys.push([
-                        1,
-                        3,
-                        ,
-                        4
-                    ]);
-                    info.ua = navigator.userAgent;
-                    info.domain = window.location.hostname;
-                    return [
-                        4,
-                        fetch("https://api.ipify.org?format=json").then(function(response) {
-                            return response.json();
-                        })
-                    ];
-                case 2:
-                    ipInfo = _state.sent();
-                    info.ip = ipInfo.ip;
-                    return [
-                        3,
-                        4
-                    ];
-                case 3:
-                    error = _state.sent();
-                    console.log("Error getting info", error);
-                    return [
-                        3,
-                        4
-                    ];
-                case 4:
-                    return [
-                        2,
-                        info
-                    ];
+            info = {};
+            try {
+                info.ua = navigator.userAgent;
+                info.domain = window.location.hostname;
+            } catch (error) {
+                console.log("Error getting info", error);
             }
+            return [
+                2,
+                info
+            ];
         });
     });
     return _getGeneralInfo.apply(this, arguments);
@@ -20607,220 +20591,3607 @@ var KevelProvider = /*#__PURE__*/ function(ContentProvider) {
     ]);
     return KevelProvider;
 }(ContentProvider);
-// src/Ads/Providers/SmartyAds/SmartyAdsSDK.ts
-import { TCModel, TCString, GVL } from "@iabtcf/core";
-GVL.baseUrl = "https://vendor-list.consensu.org/v3/";
-var PARAMS = [
-    "res",
-    "m",
-    "ua",
-    "ip",
-    "w",
-    "h",
-    "gdpr",
-    "gdpr_consent",
-    "gpp",
-    "gpp_sid",
-    "coppa",
-    "page",
-    "domain",
-    "secure",
-    "lmt",
-    "dnt",
-    "ad_width",
-    "ad_height",
-    "language",
-    "cattax",
-    "keywords",
-    "placementId"
-];
-var SmartyadsSDK = /*#__PURE__*/ function() {
+// node_modules/@iabtcf/core/lib/mjs/errors/DecodingError.js
+var DecodingError = /*#__PURE__*/ function(Error1) {
     "use strict";
-    function SmartyadsSDK() {
-        _class_call_check(this, SmartyadsSDK);
+    _inherits(DecodingError, Error1);
+    var _super = _create_super(DecodingError);
+    function DecodingError(msg) {
+        _class_call_check(this, DecodingError);
+        var _this;
+        _this = _super.call(this, msg);
+        _this.name = "DecodingError";
+        return _this;
     }
-    _create_class(SmartyadsSDK, [
-        {
-            key: "generateTCString",
-            value: function generateTCString() {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var tcModel;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!!_this.gdprConsent) return [
-                                    3,
-                                    2
-                                ];
-                                tcModel = new TCModel(new GVL());
-                                tcModel.vendorConsents.set(534);
-                                return [
-                                    4,
-                                    tcModel.gvl.readyPromise
-                                ];
-                            case 1:
-                                _state.sent();
-                                _this.gdprConsent = TCString.encode(tcModel);
-                                console.log(_this.gdprConsent);
-                                _state.label = 2;
-                            case 2:
-                                return [
-                                    2,
-                                    _this.gdprConsent
-                                ];
-                        }
-                    });
-                })();
-            }
-        },
-        {
-            key: "buildQueryParams",
-            value: /**
-   * Converts an object into a URL query string.
-   *
-   * @param params - The object to be converted into query parameters.
-   * @returns The query string with URL encoding.
-   */ function buildQueryParams(params) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var queryString;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!(params.gdpr === void 0)) return [
-                                    3,
-                                    2
-                                ];
-                                params.gdpr = 1;
-                                return [
-                                    4,
-                                    _this.generateTCString()
-                                ];
-                            case 1:
-                                params.gdpr_consent = _state.sent();
-                                _state.label = 2;
-                            case 2:
-                                queryString = PARAMS.map(function(key) {
-                                    var value2 = params[key];
-                                    if (value2 === null || value2 === void 0) {
-                                        return "";
-                                    }
-                                    return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value2));
-                                }).filter(function(part) {
-                                    return part.length > 0;
-                                }).join("&");
-                                return [
-                                    2,
-                                    queryString
-                                ];
-                        }
-                    });
-                })();
-            }
-        },
-        {
-            key: "request",
-            value: function request(params) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var _, _1;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                _1 = (_ = "https://n1.smartyads.com/?c=b&").concat;
-                                return [
-                                    4,
-                                    _this.buildQueryParams(params)
-                                ];
-                            case 1:
-                                return [
-                                    2,
-                                    fetch.apply(void 0, [
-                                        _1.apply(_, [
-                                            _state.sent()
-                                        ])
-                                    ]).then(function(response) {
-                                        if (!response.ok) {
-                                            throw new InternalError("Network response was not ok");
-                                        }
-                                        return response.json();
-                                    }).then(function(data) {
-                                        return data;
-                                    }).catch(function(error) {
-                                        throw error;
-                                    })
-                                ];
-                        }
-                    });
-                })();
-            }
-        }
-    ]);
-    return SmartyadsSDK;
-}();
-// src/Ads/Providers/SmartyAds/SmartyadsProvider.ts
-var SmartyadsProvider = /*#__PURE__*/ function(ContentProvider) {
+    return DecodingError;
+}(_wrap_native_super(Error));
+// node_modules/@iabtcf/core/lib/mjs/errors/EncodingError.js
+var EncodingError = /*#__PURE__*/ function(Error1) {
     "use strict";
-    _inherits(SmartyadsProvider, ContentProvider);
-    var _super = _create_super(SmartyadsProvider);
-    function SmartyadsProvider(context, options) {
-        _class_call_check(this, SmartyadsProvider);
+    _inherits(EncodingError, Error1);
+    var _super = _create_super(EncodingError);
+    function EncodingError(msg) {
+        _class_call_check(this, EncodingError);
         var _this;
-        _this = _super.call(this, context, options);
-        _this.placements = options.placements || {};
-        _this.smartyads = new SmartyadsSDK();
+        _this = _super.call(this, msg);
+        _this.name = "EncodingError";
         return _this;
     }
-    _create_class(SmartyadsProvider, [
+    return EncodingError;
+}(_wrap_native_super(Error));
+// node_modules/@iabtcf/core/lib/mjs/errors/GVLError.js
+var GVLError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(GVLError, Error1);
+    var _super = _create_super(GVLError);
+    function GVLError(msg) {
+        _class_call_check(this, GVLError);
+        var _this;
+        _this = _super.call(this, msg);
+        _this.name = "GVLError";
+        return _this;
+    }
+    return GVLError;
+}(_wrap_native_super(Error));
+// node_modules/@iabtcf/core/lib/mjs/errors/TCModelError.js
+var TCModelError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(TCModelError, Error1);
+    var _super = _create_super(TCModelError);
+    function TCModelError(fieldName, passedValue) {
+        var msg = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+        _class_call_check(this, TCModelError);
+        var _this;
+        _this = _super.call(this, "invalid value ".concat(passedValue, " passed for ").concat(fieldName, " ").concat(msg));
+        _this.name = "TCModelError";
+        return _this;
+    }
+    return TCModelError;
+}(_wrap_native_super(Error));
+// node_modules/@iabtcf/core/lib/mjs/encoder/Base64Url.js
+var Base64Url = /*#__PURE__*/ function() {
+    "use strict";
+    function Base64Url() {
+        _class_call_check(this, Base64Url);
+    }
+    _create_class(Base64Url, null, [
         {
-            key: "getPlacement",
-            value: function getPlacement(regionId) {
-                var availablePlacements = Object.keys(this.placements).map(parseInt);
-                if (!availablePlacements.length) {
-                    throw new Error("No available placements!");
-                }
-                var foundPlacement;
-                if (!regionId) {
-                    foundPlacement = this.placements[availablePlacements[0]];
-                } else {
-                    foundPlacement = this.placements[regionId];
+            key: "encode",
+            value: /**
+   * 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
+   */ function encode(str) {
+                if (!/^[0-1]+$/.test(str)) {
+                    throw new EncodingError("Invalid bitField");
                 }
-                if (typeof foundPlacement === "number") {
-                    return {
-                        id: foundPlacement
-                    };
+                var padding = str.length % this.LCM;
+                str += padding ? "0".repeat(this.LCM - padding) : "";
+                var result = "";
+                for(var i2 = 0; i2 < str.length; i2 += this.BASIS){
+                    result += this.DICT[parseInt(str.substr(i2, this.BASIS), 2)];
                 }
-                return foundPlacement;
+                return result;
             }
         },
         {
-            key: "request",
-            value: function request(params) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var _params_params, placementInfo, smartyadsContent, div, index;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!params || params.size.width === void 0 || params.size.width === 0 || params.size.height === void 0 || params.size.height === 0) {
-                                    throw new InternalError("No Params!");
-                                }
-                                placementInfo = _this.getPlacement((_params_params = params.params) === null || _params_params === void 0 ? void 0 : _params_params.regionId);
-                                return [
-                                    4,
-                                    _this.smartyads.request(_object_spread_props(_object_spread({}, _this.options), {
-                                        ad_width: placementInfo.w || params.size.width,
-                                        ad_height: placementInfo.h || params.size.height,
-                                        m: "api",
-                                        ua: _this.context.info.ua || navigator.userAgent,
-                                        w: window.innerWidth,
-                                        h: window.innerHeight,
-                                        domain: _this.context.info.domain || window.location.hostname,
-                                        page: window.location.href,
-                                        ip: _this.context.info.ip,
-                                        placementId: placementInfo.id
-                                    }))
+            key: "decode",
+            value: /**
+   * decodes a base64url encoded bitfield string
+   *
+   * @static
+   * @param {string} str - base64url encoded bitfield string to be decoded
+   * @return {string} - bitfield string
+   */ function decode(str) {
+                if (!/^[A-Za-z0-9\-_]+$/.test(str)) {
+                    throw new DecodingError("Invalidly encoded Base64URL string");
+                }
+                var result = "";
+                for(var i2 = 0; i2 < str.length; i2++){
+                    var strBits = this.REVERSE_DICT.get(str[i2]).toString(2);
+                    result += "0".repeat(this.BASIS - strBits.length) + strBits;
+                }
+                return result;
+            }
+        }
+    ]);
+    return Base64Url;
+}();
+/**
+ * Base 64 URL character set.  Different from standard Base64 char set
+ * in that '+' and '/' are replaced with '-' and '_'.
+ */ __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
+    ]
+]));
+/**
+ * log2(64) = 6
+ */ __publicField(Base64Url, "BASIS", 6);
+__publicField(Base64Url, "LCM", 24);
+// node_modules/@iabtcf/core/lib/mjs/Cloneable.js
+var Cloneable = /*#__PURE__*/ function() {
+    "use strict";
+    function Cloneable() {
+        _class_call_check(this, Cloneable);
+    }
+    _create_class(Cloneable, [
+        {
+            /**
+   * clone - returns a copy of the classes with new values and not references
+   *
+   * @return {T}
+   */ key: "clone",
+            value: function clone() {
+                var _this = this;
+                var myClone = new this.constructor();
+                var keys = Object.keys(this);
+                keys.forEach(function(key) {
+                    var value2 = _this.deepClone(_this[key]);
+                    if (value2 !== void 0) {
+                        myClone[key] = value2;
+                    }
+                });
+                return myClone;
+            }
+        },
+        {
+            /**
+   * deepClone - recursive function that makes copies of reference values
+   *
+   * @param {unknown} item
+   * @return {unknown}
+   */ key: "deepClone",
+            value: function deepClone(item) {
+                var itsType = typeof item === "undefined" ? "undefined" : _type_of(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 (_instanceof(item, Date)) {
+                        return new Date(item.getTime());
+                    } else if (item[Symbol.iterator] !== void 0) {
+                        var ar = [];
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = item[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var subItem = _step.value;
+                                ar.push(this.deepClone(subItem));
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        if (_instanceof(item, Array)) {
+                            return ar;
+                        } else {
+                            return new item.constructor(ar);
+                        }
+                    } else {
+                        var retr = {};
+                        for(var prop in item){
+                            if (item.hasOwnProperty(prop)) {
+                                retr[prop] = this.deepClone(item[prop]);
+                            }
+                        }
+                        return retr;
+                    }
+                }
+            }
+        }
+    ]);
+    return Cloneable;
+}();
+// node_modules/@iabtcf/core/lib/mjs/model/BinarySearchTree.js
+var BinarySearchTree = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(_BinarySearchTree, Cloneable);
+    var _super = _create_super(_BinarySearchTree);
+    function _BinarySearchTree() {
+        _class_call_check(this, _BinarySearchTree);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        __publicField(_assert_this_initialized(_this), "root", null);
+        return _this;
+    }
+    _create_class(_BinarySearchTree, [
+        {
+            key: "getRoot",
+            value: function getRoot() {
+                return this.root;
+            }
+        },
+        {
+            key: "isEmpty",
+            value: function isEmpty() {
+                return !this.root;
+            }
+        },
+        {
+            key: "add",
+            value: function add(value2) {
+                var node = {
+                    value: value2,
+                    left: null,
+                    right: null
+                };
+                var current;
+                if (this.isEmpty()) {
+                    this.root = node;
+                } else {
+                    current = this.root;
+                    while(true){
+                        if (value2 < current.value) {
+                            if (current.left === null) {
+                                current.left = node;
+                                break;
+                            } else {
+                                current = current.left;
+                            }
+                        } else if (value2 > current.value) {
+                            if (current.right === null) {
+                                current.right = node;
+                                break;
+                            } else {
+                                current = current.right;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            /**
+   * performs Morris in-order traversal
+   * @return {number[]} sorted array
+   */ key: "get",
+            value: function get() {
+                var retr = [];
+                var current = this.root;
+                while(current){
+                    if (!current.left) {
+                        retr.push(current.value);
+                        current = current.right;
+                    } else {
+                        var pre = current.left;
+                        while(pre.right && pre.right != current){
+                            pre = pre.right;
+                        }
+                        if (pre.right == current) {
+                            pre.right = null;
+                            retr.push(current.value);
+                            current = current.right;
+                        } else {
+                            pre.right = current;
+                            current = current.left;
+                        }
+                    }
+                }
+                return retr;
+            }
+        },
+        {
+            key: "contains",
+            value: function contains(value2) {
+                var retr = false;
+                var current = this.root;
+                while(current){
+                    if (current.value === value2) {
+                        retr = true;
+                        break;
+                    } else if (value2 > current.value) {
+                        current = current.right;
+                    } else if (value2 < current.value) {
+                        current = current.left;
+                    }
+                }
+                return retr;
+            }
+        },
+        {
+            key: "min",
+            value: function min() {
+                var current = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.root;
+                var retr;
+                while(current){
+                    if (current.left) {
+                        current = current.left;
+                    } else {
+                        retr = current.value;
+                        current = null;
+                    }
+                }
+                return retr;
+            }
+        },
+        {
+            key: "max",
+            value: function max() {
+                var current = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.root;
+                var retr;
+                while(current){
+                    if (current.right) {
+                        current = current.right;
+                    } else {
+                        retr = current.value;
+                        current = null;
+                    }
+                }
+                return retr;
+            }
+        },
+        {
+            key: "remove",
+            value: function remove(value2) {
+                var current = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.root;
+                var parent = null;
+                var parentSide = "left";
+                while(current){
+                    if (value2 < current.value) {
+                        parent = current;
+                        current = current.left;
+                        parentSide = "left";
+                    } else if (value2 > current.value) {
+                        parent = current;
+                        current = current.right;
+                        parentSide = "right";
+                    } else {
+                        if (!current.left && !current.right) {
+                            if (parent) {
+                                parent[parentSide] = null;
+                            } else {
+                                this.root = null;
+                            }
+                        } else if (!current.left) {
+                            if (parent) {
+                                parent[parentSide] = current.right;
+                            } else {
+                                this.root = current.right;
+                            }
+                        } else if (!current.right) {
+                            if (parent) {
+                                parent[parentSide] = current.left;
+                            } else {
+                                this.root = current.left;
+                            }
+                        } else {
+                            var minVal = this.min(current.right);
+                            this.remove(minVal, current.right);
+                            current.value = minVal;
+                        }
+                        current = null;
+                    }
+                }
+            }
+        }
+    ], [
+        {
+            key: "build",
+            value: /**
+   * Build Binary Search Tree from the ordered number array.
+   *  The depth of the tree will be the `log2` of the array length.
+   * @param {number[]} values number array in ascending order
+   * @return {BinarySearchTree} Binary Search Tree
+   */ function build(values) {
+                if (!values || values.length === 0) {
+                    return null;
+                } else if (values.length === 1) {
+                    var tree = new _BinarySearchTree();
+                    tree.add(values[0]);
+                    return tree;
+                } else {
+                    var rootIndex = values.length >> 1;
+                    var tree1 = new _BinarySearchTree();
+                    tree1.add(values[rootIndex]);
+                    var root = tree1.getRoot();
+                    if (root) {
+                        if (rootIndex + 1 < values.length) {
+                            var rightTree = _BinarySearchTree.build(values.slice(rootIndex + 1));
+                            root.right = rightTree ? rightTree.getRoot() : null;
+                        }
+                        if (rootIndex - 1 > 0) {
+                            var leftTree = _BinarySearchTree.build(values.slice(0, rootIndex - 1));
+                            root.left = leftTree ? leftTree.getRoot() : null;
+                        }
+                    }
+                    return tree1;
+                }
+            }
+        }
+    ]);
+    return _BinarySearchTree;
+}(Cloneable);
+// node_modules/@iabtcf/core/lib/mjs/model/ConsentLanguages.js
+var _ConsentLanguages = /*#__PURE__*/ function() {
+    "use strict";
+    function _ConsentLanguages() {
+        _class_call_check(this, _ConsentLanguages);
+    }
+    _create_class(_ConsentLanguages, [
+        {
+            key: "has",
+            value: function has(key) {
+                return _ConsentLanguages.langSet.has(key);
+            }
+        },
+        {
+            key: "forEach",
+            value: function forEach(callback) {
+                _ConsentLanguages.langSet.forEach(callback);
+            }
+        },
+        {
+            key: "size",
+            get: function get() {
+                return _ConsentLanguages.langSet.size;
+            }
+        }
+    ]);
+    return _ConsentLanguages;
+}();
+__publicField(_ConsentLanguages, "langSet", /* @__PURE__ */ new Set([
+    "BG",
+    "CA",
+    "CS",
+    "DA",
+    "DE",
+    "EL",
+    "EN",
+    "ES",
+    "ET",
+    "FI",
+    "FR",
+    "HR",
+    "HU",
+    "IT",
+    "JA",
+    "LT",
+    "LV",
+    "MT",
+    "NL",
+    "NO",
+    "PL",
+    "PT",
+    "RO",
+    "RU",
+    "SK",
+    "SL",
+    "SV",
+    "TR",
+    "ZH"
+]));
+var ConsentLanguages = _ConsentLanguages;
+// node_modules/@iabtcf/core/lib/mjs/model/Fields.js
+var Fields = function Fields() {
+    "use strict";
+    _class_call_check(this, 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, "useNonStandardStacks", "useNonStandardStacks");
+__publicField(Fields, "vendorConsents", "vendorConsents");
+__publicField(Fields, "vendorLegitimateInterests", "vendorLegitimateInterests");
+__publicField(Fields, "vendorListVersion", "vendorListVersion");
+__publicField(Fields, "vendorsAllowed", "vendorsAllowed");
+__publicField(Fields, "vendorsDisclosed", "vendorsDisclosed");
+__publicField(Fields, "version", "version");
+// node_modules/@iabtcf/core/lib/mjs/model/RestrictionType.js
+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 = {}));
+// node_modules/@iabtcf/core/lib/mjs/model/PurposeRestriction.js
+var _PurposeRestriction = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(_PurposeRestriction, Cloneable);
+    var _super = _create_super(_PurposeRestriction);
+    function _PurposeRestriction(purposeId, restrictionType) {
+        _class_call_check(this, _PurposeRestriction);
+        var _this;
+        _this = _super.call(this);
+        __publicField(_assert_this_initialized(_this), "purposeId_");
+        __publicField(_assert_this_initialized(_this), "restrictionType");
+        if (purposeId !== void 0) {
+            _this.purposeId = purposeId;
+        }
+        if (restrictionType !== void 0) {
+            _this.restrictionType = restrictionType;
+        }
+        return _this;
+    }
+    _create_class(_PurposeRestriction, [
+        {
+            key: "hash",
+            get: function get() {
+                if (!this.isValid()) {
+                    throw new Error("cannot hash invalid PurposeRestriction");
+                }
+                return "".concat(this.purposeId).concat(_PurposeRestriction.hashSeparator).concat(this.restrictionType);
+            }
+        },
+        {
+            key: "purposeId",
+            get: /**
+   * @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.
+   */ function get() {
+                return this.purposeId_;
+            },
+            set: /**
+   * @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.
+   */ function set(idNum) {
+                this.purposeId_ = idNum;
+            }
+        },
+        {
+            key: "isValid",
+            value: function isValid() {
+                return Number.isInteger(this.purposeId) && this.purposeId > 0 && (this.restrictionType === RestrictionType.NOT_ALLOWED || this.restrictionType === RestrictionType.REQUIRE_CONSENT || this.restrictionType === RestrictionType.REQUIRE_LI);
+            }
+        },
+        {
+            key: "isSameAs",
+            value: function isSameAs(otherPR) {
+                return this.purposeId === otherPR.purposeId && this.restrictionType === otherPR.restrictionType;
+            }
+        }
+    ], [
+        {
+            key: "unHash",
+            value: function unHash(hash) {
+                var splitUp = hash.split(this.hashSeparator);
+                var purpRestriction = new _PurposeRestriction();
+                if (splitUp.length !== 2) {
+                    throw new TCModelError("hash", hash);
+                }
+                purpRestriction.purposeId = parseInt(splitUp[0], 10);
+                purpRestriction.restrictionType = parseInt(splitUp[1], 10);
+                return purpRestriction;
+            }
+        }
+    ]);
+    return _PurposeRestriction;
+}(Cloneable);
+__publicField(_PurposeRestriction, "hashSeparator", "-");
+var PurposeRestriction = _PurposeRestriction;
+// node_modules/@iabtcf/core/lib/mjs/model/PurposeRestrictionVector.js
+var PurposeRestrictionVector = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(PurposeRestrictionVector, Cloneable);
+    var _super = _create_super(PurposeRestrictionVector);
+    function PurposeRestrictionVector() {
+        _class_call_check(this, PurposeRestrictionVector);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        /**
+     * if this originatd from an encoded string we'll need a place to store the
+     * bit length; it can be set and got from here
+     */ __publicField(_assert_this_initialized(_this), "bitLength", 0);
+        /**
+     * a map indexed by a string which will be a 'hash' of the purpose and
+     * restriction type.
+     *
+     * Using a BST to keep vendors in a sorted order for encoding later
+     */ __publicField(_assert_this_initialized(_this), "map", /* @__PURE__ */ new Map());
+        __publicField(_assert_this_initialized(_this), "gvl_");
+        return _this;
+    }
+    _create_class(PurposeRestrictionVector, [
+        {
+            key: "has",
+            value: function has(hash) {
+                return this.map.has(hash);
+            }
+        },
+        {
+            key: "isOkToHave",
+            value: function isOkToHave(restrictionType, purposeId, vendorId) {
+                var _this_gvl;
+                var result = true;
+                if ((_this_gvl = this.gvl) === null || _this_gvl === void 0 ? void 0 : _this_gvl.vendors) {
+                    var 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}
+   */ key: "add",
+            value: function add(vendorId, purposeRestriction) {
+                if (this.isOkToHave(purposeRestriction.restrictionType, purposeRestriction.purposeId, vendorId)) {
+                    var hash = purposeRestriction.hash;
+                    if (!this.has(hash)) {
+                        this.map.set(hash, new BinarySearchTree());
+                        this.bitLength = 0;
+                    }
+                    this.map.get(hash).add(vendorId);
+                }
+            }
+        },
+        {
+            /**
+   * restrictPurposeToLegalBasis - adds all Vendors under a given Purpose Restriction
+   *
+   * @param {PurposeRestriction} purposeRestriction
+   * @return {void}
+   */ key: "restrictPurposeToLegalBasis",
+            value: function restrictPurposeToLegalBasis(purposeRestriction) {
+                var vendors = this.gvl.vendorIds;
+                var hash = purposeRestriction.hash;
+                var lastEntry = function() {
+                    var value2;
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = vendors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            value2 = _step.value;
+                            ;
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    return value2;
+                }();
+                var values = _to_consumable_array(Array(lastEntry).keys()).map(function(i2) {
+                    return i2 + 1;
+                });
+                for(var i2 = 1; i2 <= lastEntry; i2++){
+                    if (!this.has(hash)) {
+                        this.map.set(hash, BinarySearchTree.build(values));
+                        this.bitLength = 0;
+                    }
+                    this.map.get(hash).add(i2);
+                }
+            }
+        },
+        {
+            /**
+   * 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
+   */ key: "getVendors",
+            value: function getVendors(purposeRestriction) {
+                var vendorIds = [];
+                if (purposeRestriction) {
+                    var hash = purposeRestriction.hash;
+                    if (this.has(hash)) {
+                        vendorIds = this.map.get(hash).get();
+                    }
+                } else {
+                    var vendorSet = /* @__PURE__ */ new Set();
+                    this.map.forEach(function(bst) {
+                        bst.get().forEach(function(vendorId) {
+                            vendorSet.add(vendorId);
+                        });
+                    });
+                    vendorIds = Array.from(vendorSet);
+                }
+                return vendorIds;
+            }
+        },
+        {
+            key: "getRestrictionType",
+            value: function getRestrictionType(vendorId, purposeId) {
+                var rType;
+                this.getRestrictions(vendorId).forEach(function(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
+   */ key: "vendorHasRestriction",
+            value: function vendorHasRestriction(vendorId, purposeRestriction) {
+                var has = false;
+                var restrictions = this.getRestrictions(vendorId);
+                for(var i2 = 0; i2 < restrictions.length && !has; i2++){
+                    has = purposeRestriction.isSameAs(restrictions[i2]);
+                }
+                return has;
+            }
+        },
+        {
+            /**
+   * getMaxVendorId - gets the Maximum Vendor ID regardless of Purpose
+   * Restriction
+   *
+   * @return {number} - maximum Vendor ID
+   */ key: "getMaxVendorId",
+            value: function getMaxVendorId() {
+                var retr = 0;
+                this.map.forEach(function(bst) {
+                    retr = Math.max(bst.max(), retr);
+                });
+                return retr;
+            }
+        },
+        {
+            key: "getRestrictions",
+            value: function getRestrictions(vendorId) {
+                var retr = [];
+                this.map.forEach(function(bst, hash) {
+                    if (vendorId) {
+                        if (bst.contains(vendorId)) {
+                            retr.push(PurposeRestriction.unHash(hash));
+                        }
+                    } else {
+                        retr.push(PurposeRestriction.unHash(hash));
+                    }
+                });
+                return retr;
+            }
+        },
+        {
+            key: "getPurposes",
+            value: function getPurposes() {
+                var purposeIds = /* @__PURE__ */ new Set();
+                this.map.forEach(function(bst, 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}
+   */ key: "remove",
+            value: function remove(vendorId, purposeRestriction) {
+                var hash = purposeRestriction.hash;
+                var bst = this.map.get(hash);
+                if (bst) {
+                    bst.remove(vendorId);
+                    if (bst.isEmpty()) {
+                        this.map.delete(hash);
+                        this.bitLength = 0;
+                    }
+                }
+            }
+        },
+        {
+            key: "gvl",
+            get: /**
+   * gvl returns local copy of the GVL these restrictions apply to
+   *
+   * @return {GVL}
+   */ function get() {
+                return this.gvl_;
+            },
+            set: /**
+   * 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
+   */ function set(value2) {
+                var _this = this;
+                if (!this.gvl_) {
+                    this.gvl_ = value2;
+                    this.map.forEach(function(bst, hash) {
+                        var purposeRestriction = PurposeRestriction.unHash(hash);
+                        var vendors = bst.get();
+                        vendors.forEach(function(vendorId) {
+                            if (!_this.isOkToHave(purposeRestriction.restrictionType, purposeRestriction.purposeId, vendorId)) {
+                                bst.remove(vendorId);
+                            }
+                        });
+                    });
+                }
+            }
+        },
+        {
+            /**
+   * isEmpty - whether or not this vector has any restrictions in it
+   *
+   * @return {boolean}
+   */ key: "isEmpty",
+            value: function isEmpty() {
+                return this.map.size === 0;
+            }
+        },
+        {
+            key: "numRestrictions",
+            get: /**
+   * numRestrictions - returns the number of Purpose Restrictions.
+   *
+   * @return {number}
+   */ function get() {
+                return this.map.size;
+            }
+        }
+    ]);
+    return PurposeRestrictionVector;
+}(Cloneable);
+// node_modules/@iabtcf/core/lib/mjs/model/DeviceDisclosureStorageAccessType.js
+var DeviceDisclosureStorageAccessType;
+(function(DeviceDisclosureStorageAccessType2) {
+    DeviceDisclosureStorageAccessType2["COOKIE"] = "cookie";
+    DeviceDisclosureStorageAccessType2["WEB"] = "web";
+    DeviceDisclosureStorageAccessType2["APP"] = "app";
+})(DeviceDisclosureStorageAccessType || (DeviceDisclosureStorageAccessType = {}));
+// node_modules/@iabtcf/core/lib/mjs/model/Segment.js
+var Segment;
+(function(Segment2) {
+    Segment2["CORE"] = "core";
+    Segment2["VENDORS_DISCLOSED"] = "vendorsDisclosed";
+    Segment2["VENDORS_ALLOWED"] = "vendorsAllowed";
+    Segment2["PUBLISHER_TC"] = "publisherTC";
+})(Segment || (Segment = {}));
+// node_modules/@iabtcf/core/lib/mjs/model/SegmentIDs.js
+var SegmentIDs = function SegmentIDs() {
+    "use strict";
+    _class_call_check(this, SegmentIDs);
+};
+/**
+ * 0 = default - reserved for core string (does not need to be present in the core string)
+ * 1 = OOB vendors disclosed
+ * 2 = OOB vendors allowed
+ * 3 = PublisherTC
+ */ __publicField(SegmentIDs, "ID_TO_KEY", [
+    Segment.CORE,
+    Segment.VENDORS_DISCLOSED,
+    Segment.VENDORS_ALLOWED,
+    Segment.PUBLISHER_TC
+]);
+var _obj;
+__publicField(SegmentIDs, "KEY_TO_ID", (_obj = {}, _define_property(_obj, Segment.CORE, 0), _define_property(_obj, Segment.VENDORS_DISCLOSED, 1), _define_property(_obj, Segment.VENDORS_ALLOWED, 2), _define_property(_obj, Segment.PUBLISHER_TC, 3), _obj));
+// node_modules/@iabtcf/core/lib/mjs/model/Vector.js
+var Vector = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(Vector, Cloneable);
+    var _super = _create_super(Vector);
+    function Vector() {
+        _class_call_check(this, Vector);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        /**
+     * if this originatd from an encoded string we'll need a place to store the
+     * bit length; it can be set and got from here
+     */ __publicField(_assert_this_initialized(_this), "bitLength", 0);
+        __publicField(_assert_this_initialized(_this), "maxId_", 0);
+        __publicField(_assert_this_initialized(_this), "set_", /* @__PURE__ */ new Set());
+        return _this;
+    }
+    _create_class(Vector, [
+        {
+            key: Symbol.iterator,
+            value: function value() {
+                var i2;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            i2 = 1;
+                            _state.label = 1;
+                        case 1:
+                            if (!(i2 <= this.maxId)) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                [
+                                    i2,
+                                    this.has(i2)
+                                ]
+                            ];
+                        case 2:
+                            _state.sent();
+                            _state.label = 3;
+                        case 3:
+                            i2++;
+                            return [
+                                3,
+                                1
+                            ];
+                        case 4:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            }
+        },
+        {
+            /**
+   * values()
+   *
+   * @return {IterableIterator<number>} - returns an iterator of the positive
+   * values in the set
+   */ key: "values",
+            value: function values() {
+                return this.set_.values();
+            }
+        },
+        {
+            key: "maxId",
+            get: /**
+   * maxId
+   *
+   * @return {number} - the highest id in this Vector
+   */ function get() {
+                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
+   */ key: "has",
+            value: function has(id) {
+                return this.set_.has(id);
+            }
+        },
+        {
+            /**
+   * unset
+   *
+   * @param {SingleIDOrCollection} id - id or ids to unset
+   * @return {void}
+   */ key: "unset",
+            value: function unset(id) {
+                var _this = this;
+                if (Array.isArray(id)) {
+                    id.forEach(function(id2) {
+                        return _this.unset(id2);
+                    });
+                } else if (typeof id === "object") {
+                    this.unset(Object.keys(id).map(function(strId) {
+                        return Number(strId);
+                    }));
+                } else {
+                    this.set_.delete(Number(id));
+                    this.bitLength = 0;
+                    if (id === this.maxId) {
+                        this.maxId_ = 0;
+                        this.set_.forEach(function(id2) {
+                            _this.maxId_ = Math.max(_this.maxId, id2);
+                        });
+                    }
+                }
+            }
+        },
+        {
+            key: "isIntMap",
+            value: function isIntMap(item) {
+                var _this = this;
+                var result = typeof item === "object";
+                result = result && Object.keys(item).every(function(key) {
+                    var itemResult = Number.isInteger(parseInt(key, 10));
+                    itemResult = itemResult && _this.isValidNumber(item[key].id);
+                    itemResult = itemResult && item[key].name !== void 0;
+                    return itemResult;
+                });
+                return result;
+            }
+        },
+        {
+            key: "isValidNumber",
+            value: function isValidNumber(item) {
+                return parseInt(item, 10) > 0;
+            }
+        },
+        {
+            key: "isSet",
+            value: function isSet(item) {
+                var result = false;
+                if (_instanceof(item, 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}
+   */ key: "set",
+            value: function set(item) {
+                var _this = this;
+                if (Array.isArray(item)) {
+                    item.forEach(function(item2) {
+                        return _this.set(item2);
+                    });
+                } else if (this.isSet(item)) {
+                    this.set(Array.from(item));
+                } else if (this.isIntMap(item)) {
+                    this.set(Object.keys(item).map(function(strId) {
+                        return 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");
+                }
+            }
+        },
+        {
+            key: "empty",
+            value: function 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
+   */ key: "forEach",
+            value: function forEach(callback) {
+                for(var i2 = 1; i2 <= this.maxId; i2++){
+                    callback(this.has(i2), i2);
+                }
+            }
+        },
+        {
+            key: "size",
+            get: function get() {
+                return this.set_.size;
+            }
+        },
+        {
+            key: "setAll",
+            value: function setAll(intMap) {
+                this.set(intMap);
+            }
+        }
+    ]);
+    return Vector;
+}(Cloneable);
+// node_modules/@iabtcf/core/lib/mjs/encoder/BitLength.js
+var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+var BitLength = function BitLength() {
+    "use strict";
+    _class_call_check(this, 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.useNonStandardStacks, _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);
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/BooleanEncoder.js
+var BooleanEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function BooleanEncoder() {
+        _class_call_check(this, BooleanEncoder);
+    }
+    _create_class(BooleanEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2) {
+                return String(Number(value2));
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2) {
+                return value2 === "1";
+            }
+        }
+    ]);
+    return BooleanEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/IntEncoder.js
+var IntEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function IntEncoder() {
+        _class_call_check(this, IntEncoder);
+    }
+    _create_class(IntEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2, numBits) {
+                var bitString;
+                if (typeof value2 === "string") {
+                    value2 = parseInt(value2, 10);
+                }
+                bitString = value2.toString(2);
+                if (bitString.length > numBits || value2 < 0) {
+                    throw new EncodingError("".concat(value2, " too large to encode into ").concat(numBits));
+                }
+                if (bitString.length < numBits) {
+                    bitString = "0".repeat(numBits - bitString.length) + bitString;
+                }
+                return bitString;
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2, numBits) {
+                if (numBits !== value2.length) {
+                    throw new DecodingError("invalid bit length");
+                }
+                return parseInt(value2, 2);
+            }
+        }
+    ]);
+    return IntEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/DateEncoder.js
+var DateEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function DateEncoder() {
+        _class_call_check(this, DateEncoder);
+    }
+    _create_class(DateEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2, numBits) {
+                return IntEncoder.encode(Math.round(value2.getTime() / 100), numBits);
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2, numBits) {
+                if (numBits !== value2.length) {
+                    throw new DecodingError("invalid bit length");
+                }
+                var date = /* @__PURE__ */ new Date();
+                date.setTime(IntEncoder.decode(value2, numBits) * 100);
+                return date;
+            }
+        }
+    ]);
+    return DateEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/FixedVectorEncoder.js
+var FixedVectorEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function FixedVectorEncoder() {
+        _class_call_check(this, FixedVectorEncoder);
+    }
+    _create_class(FixedVectorEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2, numBits) {
+                var bitString = "";
+                for(var i2 = 1; i2 <= numBits; i2++){
+                    bitString += BooleanEncoder.encode(value2.has(i2));
+                }
+                return bitString;
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2, numBits) {
+                if (value2.length !== numBits) {
+                    throw new DecodingError("bitfield encoding length mismatch");
+                }
+                var vector = new Vector();
+                for(var i2 = 1; i2 <= numBits; i2++){
+                    if (BooleanEncoder.decode(value2[i2 - 1])) {
+                        vector.set(i2);
+                    }
+                }
+                vector.bitLength = value2.length;
+                return vector;
+            }
+        }
+    ]);
+    return FixedVectorEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/LangEncoder.js
+var LangEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function LangEncoder() {
+        _class_call_check(this, LangEncoder);
+    }
+    _create_class(LangEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2, numBits) {
+                value2 = value2.toUpperCase();
+                var ASCII_START = 65;
+                var firstLetter = value2.charCodeAt(0) - ASCII_START;
+                var secondLetter = value2.charCodeAt(1) - ASCII_START;
+                if (firstLetter < 0 || firstLetter > 25 || secondLetter < 0 || secondLetter > 25) {
+                    throw new EncodingError("invalid language code: ".concat(value2));
+                }
+                if (numBits % 2 === 1) {
+                    throw new EncodingError("numBits must be even, ".concat(numBits, " is not valid"));
+                }
+                numBits = numBits / 2;
+                var firstLetterBString = IntEncoder.encode(firstLetter, numBits);
+                var secondLetterBString = IntEncoder.encode(secondLetter, numBits);
+                return firstLetterBString + secondLetterBString;
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2, numBits) {
+                var retr;
+                if (numBits === value2.length && !(value2.length % 2)) {
+                    var ASCII_START = 65;
+                    var mid = value2.length / 2;
+                    var firstLetter = IntEncoder.decode(value2.slice(0, mid), mid) + ASCII_START;
+                    var secondLetter = IntEncoder.decode(value2.slice(mid), mid) + ASCII_START;
+                    retr = String.fromCharCode(firstLetter) + String.fromCharCode(secondLetter);
+                } else {
+                    throw new DecodingError("invalid bit length for language");
+                }
+                return retr;
+            }
+        }
+    ]);
+    return LangEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/PurposeRestrictionVectorEncoder.js
+var PurposeRestrictionVectorEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function PurposeRestrictionVectorEncoder() {
+        _class_call_check(this, PurposeRestrictionVectorEncoder);
+    }
+    _create_class(PurposeRestrictionVectorEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(prVector) {
+                var bitString = IntEncoder.encode(prVector.numRestrictions, BitLength.numRestrictions);
+                if (!prVector.isEmpty()) {
+                    prVector.getRestrictions().forEach(function(purpRestriction) {
+                        var _loop = function(i2) {
+                            var vendorId = vendors[i2];
+                            if (startId === 0) {
+                                numEntries++;
+                                startId = vendorId;
+                            }
+                            var lastVendorId = vendors[len - 1];
+                            var gvlVendorIds = prVector.gvl.vendorIds;
+                            var nextGvlVendor = function(vendorId2) {
+                                while(++vendorId2 <= lastVendorId && !gvlVendorIds.has(vendorId2)){}
+                                return vendorId2;
+                            };
+                            if (i2 === len - 1 || vendors[i2 + 1] > nextGvlVendor(vendorId)) {
+                                var 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(purpRestriction.purposeId, BitLength.purposeId);
+                        bitString += IntEncoder.encode(purpRestriction.restrictionType, BitLength.restrictionType);
+                        var vendors = prVector.getVendors(purpRestriction);
+                        var len = vendors.length;
+                        var numEntries = 0;
+                        var startId = 0;
+                        var rangeField = "";
+                        for(var i2 = 0; i2 < len; i2++)_loop(i2);
+                        bitString += IntEncoder.encode(numEntries, BitLength.numEntries);
+                        bitString += rangeField;
+                    });
+                }
+                return bitString;
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(encodedString) {
+                var index = 0;
+                var vector = new PurposeRestrictionVector();
+                var numRestrictions = IntEncoder.decode(encodedString.substr(index, BitLength.numRestrictions), BitLength.numRestrictions);
+                index += BitLength.numRestrictions;
+                for(var i2 = 0; i2 < numRestrictions; i2++){
+                    var purposeId = IntEncoder.decode(encodedString.substr(index, BitLength.purposeId), BitLength.purposeId);
+                    index += BitLength.purposeId;
+                    var restrictionType = IntEncoder.decode(encodedString.substr(index, BitLength.restrictionType), BitLength.restrictionType);
+                    index += BitLength.restrictionType;
+                    var purposeRestriction = new PurposeRestriction(purposeId, restrictionType);
+                    var numEntries = IntEncoder.decode(encodedString.substr(index, BitLength.numEntries), BitLength.numEntries);
+                    index += BitLength.numEntries;
+                    for(var j = 0; j < numEntries; j++){
+                        var isARange = BooleanEncoder.decode(encodedString.substr(index, BitLength.anyBoolean));
+                        index += BitLength.anyBoolean;
+                        var startOrOnlyVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+                        index += BitLength.vendorId;
+                        if (isARange) {
+                            var endVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+                            index += BitLength.vendorId;
+                            if (endVendorId < startOrOnlyVendorId) {
+                                throw new DecodingError("Invalid RangeEntry: endVendorId ".concat(endVendorId, " is less than ").concat(startOrOnlyVendorId));
+                            }
+                            for(var k = startOrOnlyVendorId; k <= endVendorId; k++){
+                                vector.add(k, purposeRestriction);
+                            }
+                        } else {
+                            vector.add(startOrOnlyVendorId, purposeRestriction);
+                        }
+                    }
+                }
+                vector.bitLength = index;
+                return vector;
+            }
+        }
+    ]);
+    return PurposeRestrictionVectorEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/VectorEncodingType.js
+var VectorEncodingType;
+(function(VectorEncodingType2) {
+    VectorEncodingType2[VectorEncodingType2["FIELD"] = 0] = "FIELD";
+    VectorEncodingType2[VectorEncodingType2["RANGE"] = 1] = "RANGE";
+})(VectorEncodingType || (VectorEncodingType = {}));
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/VendorVectorEncoder.js
+var VendorVectorEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function VendorVectorEncoder() {
+        _class_call_check(this, VendorVectorEncoder);
+    }
+    _create_class(VendorVectorEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(value2) {
+                var ranges = [];
+                var range = [];
+                var retrString = IntEncoder.encode(value2.maxId, BitLength.maxId);
+                var bitField = "";
+                var rangeIsSmaller;
+                var headerLength = BitLength.maxId + BitLength.encodingType;
+                var bitFieldLength = headerLength + value2.maxId;
+                var minRangeLength = BitLength.vendorId * 2 + BitLength.singleOrRange + BitLength.numEntries;
+                var rangeLength = headerLength + BitLength.numEntries;
+                value2.forEach(function(curValue, i2) {
+                    bitField += BooleanEncoder.encode(curValue);
+                    rangeIsSmaller = value2.maxId > minRangeLength && rangeLength < bitFieldLength;
+                    if (rangeIsSmaller && curValue) {
+                        var nextValue = value2.has(i2 + 1);
+                        if (!nextValue) {
+                            range.push(i2);
+                            rangeLength += BitLength.vendorId;
+                            ranges.push(range);
+                            range = [];
+                        } else if (range.length === 0) {
+                            range.push(i2);
+                            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;
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(value2, version) {
+                var vector;
+                var index = 0;
+                var maxId = IntEncoder.decode(value2.substr(index, BitLength.maxId), BitLength.maxId);
+                index += BitLength.maxId;
+                var encodingType = IntEncoder.decode(value2.charAt(index), BitLength.encodingType);
+                index += BitLength.encodingType;
+                if (encodingType === VectorEncodingType.RANGE) {
+                    vector = new Vector();
+                    if (version === 1) {
+                        if (value2.substr(index, 1) === "1") {
+                            throw new DecodingError("Unable to decode default consent=1");
+                        }
+                        index++;
+                    }
+                    var numEntries = IntEncoder.decode(value2.substr(index, BitLength.numEntries), BitLength.numEntries);
+                    index += BitLength.numEntries;
+                    for(var i2 = 0; i2 < numEntries; i2++){
+                        var isIdRange = BooleanEncoder.decode(value2.charAt(index));
+                        index += BitLength.singleOrRange;
+                        var firstId = IntEncoder.decode(value2.substr(index, BitLength.vendorId), BitLength.vendorId);
+                        index += BitLength.vendorId;
+                        if (isIdRange) {
+                            var secondId = IntEncoder.decode(value2.substr(index, BitLength.vendorId), BitLength.vendorId);
+                            index += BitLength.vendorId;
+                            for(var j = firstId; j <= secondId; j++){
+                                vector.set(j);
+                            }
+                        } else {
+                            vector.set(firstId);
+                        }
+                    }
+                } else {
+                    var bitField = value2.substr(index, maxId);
+                    index += maxId;
+                    vector = FixedVectorEncoder.decode(bitField, maxId);
+                }
+                vector.bitLength = index;
+                return vector;
+            }
+        },
+        {
+            key: "buildRangeEncoding",
+            value: function buildRangeEncoding(ranges) {
+                var numEntries = ranges.length;
+                var rangeString = IntEncoder.encode(numEntries, BitLength.numEntries);
+                ranges.forEach(function(range) {
+                    var 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;
+            }
+        }
+    ]);
+    return VendorVectorEncoder;
+}();
+// node_modules/@iabtcf/core/lib/mjs/encoder/field/FieldEncoderMap.js
+function FieldEncoderMap() {
+    var _obj;
+    return _obj = {}, _define_property(_obj, Fields.version, IntEncoder), _define_property(_obj, Fields.created, DateEncoder), _define_property(_obj, Fields.lastUpdated, DateEncoder), _define_property(_obj, Fields.cmpId, IntEncoder), _define_property(_obj, Fields.cmpVersion, IntEncoder), _define_property(_obj, Fields.consentScreen, IntEncoder), _define_property(_obj, Fields.consentLanguage, LangEncoder), _define_property(_obj, Fields.vendorListVersion, IntEncoder), _define_property(_obj, Fields.policyVersion, IntEncoder), _define_property(_obj, Fields.isServiceSpecific, BooleanEncoder), _define_property(_obj, Fields.useNonStandardStacks, BooleanEncoder), _define_property(_obj, Fields.specialFeatureOptins, FixedVectorEncoder), _define_property(_obj, Fields.purposeConsents, FixedVectorEncoder), _define_property(_obj, Fields.purposeLegitimateInterests, FixedVectorEncoder), _define_property(_obj, Fields.purposeOneTreatment, BooleanEncoder), _define_property(_obj, Fields.publisherCountryCode, LangEncoder), _define_property(_obj, Fields.vendorConsents, VendorVectorEncoder), _define_property(_obj, Fields.vendorLegitimateInterests, VendorVectorEncoder), _define_property(_obj, Fields.publisherRestrictions, PurposeRestrictionVectorEncoder), _define_property(_obj, "segmentType", IntEncoder), _define_property(_obj, Fields.vendorsDisclosed, VendorVectorEncoder), _define_property(_obj, Fields.vendorsAllowed, VendorVectorEncoder), _define_property(_obj, Fields.publisherConsents, FixedVectorEncoder), _define_property(_obj, Fields.publisherLegitimateInterests, FixedVectorEncoder), _define_property(_obj, Fields.numCustomPurposes, IntEncoder), _define_property(_obj, Fields.publisherCustomConsents, FixedVectorEncoder), _define_property(_obj, Fields.publisherCustomLegitimateInterests, FixedVectorEncoder), _obj;
+}
+// node_modules/@iabtcf/core/lib/mjs/encoder/sequence/FieldSequence.js
+var FieldSequence = function FieldSequence() {
+    "use strict";
+    _class_call_check(this, FieldSequence);
+    __publicField(this, "1", _define_property({}, Segment.CORE, [
+        Fields.version,
+        Fields.created,
+        Fields.lastUpdated,
+        Fields.cmpId,
+        Fields.cmpVersion,
+        Fields.consentScreen,
+        Fields.consentLanguage,
+        Fields.vendorListVersion,
+        Fields.purposeConsents,
+        Fields.vendorConsents
+    ]));
+    var _obj;
+    __publicField(this, "2", (_obj = {}, _define_property(_obj, Segment.CORE, [
+        Fields.version,
+        Fields.created,
+        Fields.lastUpdated,
+        Fields.cmpId,
+        Fields.cmpVersion,
+        Fields.consentScreen,
+        Fields.consentLanguage,
+        Fields.vendorListVersion,
+        Fields.policyVersion,
+        Fields.isServiceSpecific,
+        Fields.useNonStandardStacks,
+        Fields.specialFeatureOptins,
+        Fields.purposeConsents,
+        Fields.purposeLegitimateInterests,
+        Fields.purposeOneTreatment,
+        Fields.publisherCountryCode,
+        Fields.vendorConsents,
+        Fields.vendorLegitimateInterests,
+        Fields.publisherRestrictions
+    ]), _define_property(_obj, Segment.PUBLISHER_TC, [
+        Fields.publisherConsents,
+        Fields.publisherLegitimateInterests,
+        Fields.numCustomPurposes,
+        Fields.publisherCustomConsents,
+        Fields.publisherCustomLegitimateInterests
+    ]), _define_property(_obj, Segment.VENDORS_ALLOWED, [
+        Fields.vendorsAllowed
+    ]), _define_property(_obj, Segment.VENDORS_DISCLOSED, [
+        Fields.vendorsDisclosed
+    ]), _obj));
+};
+// node_modules/@iabtcf/core/lib/mjs/encoder/sequence/SegmentSequence.js
+var SegmentSequence = function SegmentSequence(tcModel, options) {
+    "use strict";
+    _class_call_check(this, SegmentSequence);
+    __publicField(this, "1", [
+        Segment.CORE
+    ]);
+    __publicField(this, "2", [
+        Segment.CORE
+    ]);
+    if (tcModel.version === 2) {
+        if (tcModel.isServiceSpecific) {
+            this["2"].push(Segment.PUBLISHER_TC);
+        } else {
+            var 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);
+            }
+        }
+    }
+};
+// node_modules/@iabtcf/core/lib/mjs/encoder/SegmentEncoder.js
+var SegmentEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function SegmentEncoder() {
+        _class_call_check(this, SegmentEncoder);
+    }
+    _create_class(SegmentEncoder, null, [
+        {
+            key: "encode",
+            value: function encode(tcModel, segment) {
+                var _this = this;
+                var sequence;
+                try {
+                    sequence = this.fieldSequence[String(tcModel.version)][segment];
+                } catch (err) {
+                    throw new EncodingError("Unable to encode version: ".concat(tcModel.version, ", segment: ").concat(segment));
+                }
+                var bitField = "";
+                if (segment !== Segment.CORE) {
+                    bitField = IntEncoder.encode(SegmentIDs.KEY_TO_ID[segment], BitLength.segmentType);
+                }
+                var fieldEncoderMap = FieldEncoderMap();
+                sequence.forEach(function(key) {
+                    var value2 = tcModel[key];
+                    var encoder = fieldEncoderMap[key];
+                    var numBits = BitLength[key];
+                    if (numBits === void 0) {
+                        if (_this.isPublisherCustom(key)) {
+                            numBits = Number(tcModel[Fields.numCustomPurposes]);
+                        }
+                    }
+                    try {
+                        bitField += encoder.encode(value2, numBits);
+                    } catch (err) {
+                        throw new EncodingError("Error encoding ".concat(segment, "->").concat(key, ": ").concat(err.message));
+                    }
+                });
+                return Base64Url.encode(bitField);
+            }
+        },
+        {
+            key: "decode",
+            value: function decode(encodedString, tcModel, segment) {
+                var _this = this;
+                var bitField = Base64Url.decode(encodedString);
+                var 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;
+                }
+                var sequence = this.fieldSequence[String(tcModel.version)][segment];
+                var fieldEncoderMap = FieldEncoderMap();
+                sequence.forEach(function(key) {
+                    var encoder = fieldEncoderMap[key];
+                    var numBits = BitLength[key];
+                    if (numBits === void 0) {
+                        if (_this.isPublisherCustom(key)) {
+                            numBits = Number(tcModel[Fields.numCustomPurposes]);
+                        }
+                    }
+                    if (numBits !== 0) {
+                        var 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;
+            }
+        },
+        {
+            key: "isPublisherCustom",
+            value: function isPublisherCustom(key) {
+                return key.indexOf("publisherCustom") === 0;
+            }
+        }
+    ]);
+    return SegmentEncoder;
+}();
+__publicField(SegmentEncoder, "fieldSequence", new FieldSequence());
+// node_modules/@iabtcf/core/lib/mjs/encoder/SemanticPreEncoder.js
+var SemanticPreEncoder = /*#__PURE__*/ function() {
+    "use strict";
+    function SemanticPreEncoder() {
+        _class_call_check(this, SemanticPreEncoder);
+    }
+    _create_class(SemanticPreEncoder, null, [
+        {
+            key: "process",
+            value: function process1(tcModel, options) {
+                var 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.toUpperCase();
+                if ((options === null || options === void 0 ? void 0 : options.version) > 0 && (options === null || options === void 0 ? void 0 : options.version) <= this.processor.length) {
+                    tcModel.version = options.version;
+                } else {
+                    tcModel.version = this.processor.length;
+                }
+                var processorFunctionIndex = tcModel.version - 1;
+                if (!this.processor[processorFunctionIndex]) {
+                    throw new EncodingError("Invalid version: ".concat(tcModel.version));
+                }
+                return this.processor[processorFunctionIndex](tcModel, gvl);
+            }
+        }
+    ]);
+    return SemanticPreEncoder;
+}();
+__publicField(SemanticPreEncoder, "processor", [
+    function(tcModel) {
+        return tcModel;
+    },
+    function(tcModel, gvl) {
+        tcModel.publisherRestrictions.gvl = gvl;
+        tcModel.purposeLegitimateInterests.unset(1);
+        var vectorToIntMap = /* @__PURE__ */ new Map();
+        vectorToIntMap.set("legIntPurposes", tcModel.vendorLegitimateInterests);
+        vectorToIntMap.set("purposes", tcModel.vendorConsents);
+        vectorToIntMap.forEach(function(vector, gvlVendorKey) {
+            vector.forEach(function(value2, vendorId) {
+                if (value2) {
+                    var 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 {
+                                    var restrictions = tcModel.publisherRestrictions.getRestrictions(vendorId);
+                                    var isValid = false;
+                                    for(var i2 = 0, len = restrictions.length; i2 < len && !isValid; i2++){
+                                        isValid = restrictions[i2].restrictionType === RestrictionType.REQUIRE_CONSENT && gvlVendorKey === "purposes" || restrictions[i2].restrictionType === RestrictionType.REQUIRE_LI && gvlVendorKey === "legIntPurposes";
+                                    }
+                                    if (!isValid) {
+                                        vector.unset(vendorId);
+                                    }
+                                }
+                            } else {
+                                vector.unset(vendorId);
+                            }
+                        }
+                    }
+                }
+            });
+        });
+        tcModel.vendorsDisclosed.set(gvl.vendors);
+        return tcModel;
+    }
+]);
+// node_modules/@iabtcf/core/lib/mjs/Json.js
+var Json = /*#__PURE__*/ function() {
+    "use strict";
+    function Json() {
+        _class_call_check(this, Json);
+    }
+    _create_class(Json, null, [
+        {
+            key: "absCall",
+            value: function absCall(url2, body, sendCookies, timeout) {
+                return new Promise(function(resolve, reject) {
+                    var req = new XMLHttpRequest();
+                    var onLoad = function() {
+                        if (req.readyState == XMLHttpRequest.DONE) {
+                            if (req.status >= 200 && req.status < 300) {
+                                var response = req.response;
+                                if (typeof response === "string") {
+                                    try {
+                                        response = JSON.parse(response);
+                                    } catch (e2) {}
+                                }
+                                resolve(response);
+                            } else {
+                                reject(new Error("HTTP Status: ".concat(req.status, " response type: ").concat(req.responseType)));
+                            }
+                        }
+                    };
+                    var onError = function() {
+                        reject(new Error("error"));
+                    };
+                    var onAbort = function() {
+                        reject(new Error("aborted"));
+                    };
+                    var onTimeout = function() {
+                        reject(new Error("Timeout " + timeout + "ms " + url2));
+                    };
+                    req.withCredentials = sendCookies;
+                    req.addEventListener("load", onLoad);
+                    req.addEventListener("error", onError);
+                    req.addEventListener("abort", onAbort);
+                    if (body === null) {
+                        req.open("GET", url2, true);
+                    } else {
+                        req.open("POST", url2, true);
+                    }
+                    req.responseType = "json";
+                    req.timeout = timeout;
+                    req.ontimeout = onTimeout;
+                    req.send(body);
+                });
+            }
+        },
+        {
+            key: "post",
+            value: /**
+   * @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
+   */ function post(url2, body) {
+                var sendCookies = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false, timeout = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
+                return this.absCall(url2, JSON.stringify(body), sendCookies, timeout);
+            }
+        },
+        {
+            key: "fetch",
+            value: /**
+   * @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
+   */ function fetch1(url2) {
+                var sendCookies = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, timeout = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+                return this.absCall(url2, null, sendCookies, timeout);
+            }
+        }
+    ]);
+    return Json;
+}();
+// node_modules/@iabtcf/core/lib/mjs/GVL.js
+var _GVL = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(_GVL, Cloneable);
+    var _super = _create_super(_GVL);
+    function _GVL(versionOrVendorList) {
+        _class_call_check(this, _GVL);
+        var _this;
+        _this = _super.call(this);
+        /**
+     * @param {Promise} resolved when this GVL object is populated with the data
+     * or rejected if there is an error.
+     */ __publicField(_assert_this_initialized(_this), "readyPromise");
+        /**
+     * @param {number} gvlSpecificationVersion - schema version for the GVL that is used
+     */ __publicField(_assert_this_initialized(_this), "gvlSpecificationVersion");
+        /**
+     * @param {number} incremented with each published file change
+     */ __publicField(_assert_this_initialized(_this), "vendorListVersion");
+        /**
+     * @param {number} tcfPolicyVersion - The TCF MO will increment this value
+     * whenever a GVL change (such as adding a new Purpose or Feature or a change
+     * in Purpose wording) legally invalidates existing TC Strings and requires
+     * CMPs to re-establish transparency and consent from users. If the policy
+     * version number in the latest GVL is different from the value in your TC
+     * String, then you need to re-establish transparency and consent for that
+     * user. A version 1 format TC String is considered to have a version value
+     * of 1.
+     */ __publicField(_assert_this_initialized(_this), "tcfPolicyVersion");
+        /**
+     * @param {string | Date} lastUpdated - the date in which the vendor list
+     * json file  was last updated.
+     */ __publicField(_assert_this_initialized(_this), "lastUpdated");
+        /**
+     * @param {IntMap<Purpose>} a collection of [[Purpose]]s
+     */ __publicField(_assert_this_initialized(_this), "purposes");
+        /**
+     * @param {IntMap<Purpose>} a collection of [[Purpose]]s
+     */ __publicField(_assert_this_initialized(_this), "specialPurposes");
+        /**
+     * @param {IntMap<Feature>} a collection of [[Feature]]s
+     */ __publicField(_assert_this_initialized(_this), "features");
+        /**
+     * @param {IntMap<Feature>} a collection of [[Feature]]s
+     */ __publicField(_assert_this_initialized(_this), "specialFeatures");
+        /**
+     * @param {boolean} internal reference of when the GVL is ready to be used
+     */ __publicField(_assert_this_initialized(_this), "isReady_", false);
+        /**
+     * @param {IntMap<Vendor>} a collection of [[Vendor]]s
+     */ __publicField(_assert_this_initialized(_this), "vendors_");
+        __publicField(_assert_this_initialized(_this), "vendorIds");
+        /**
+     * @param {IntMap<Vendor>} a collection of [[Vendor]]. Used as a backup if a whitelist is sets
+     */ __publicField(_assert_this_initialized(_this), "fullVendorList");
+        /**
+     * @param {ByPurposeVendorMap} vendors by purpose
+     */ __publicField(_assert_this_initialized(_this), "byPurposeVendorMap");
+        /**
+     * @param {IDSetMap} vendors by special purpose
+     */ __publicField(_assert_this_initialized(_this), "bySpecialPurposeVendorMap");
+        /**
+     * @param {IDSetMap} vendors by feature
+     */ __publicField(_assert_this_initialized(_this), "byFeatureVendorMap");
+        /**
+     * @param {IDSetMap} vendors by special feature
+     */ __publicField(_assert_this_initialized(_this), "bySpecialFeatureVendorMap");
+        /**
+     * @param {IntMap<Stack>} a collection of [[Stack]]s
+     */ __publicField(_assert_this_initialized(_this), "stacks");
+        __publicField(_assert_this_initialized(_this), "lang_");
+        __publicField(_assert_this_initialized(_this), "isLatest", false);
+        var url2 = _GVL.baseUrl;
+        _this.lang_ = _GVL.DEFAULT_LANGUAGE;
+        if (_this.isVendorList(versionOrVendorList)) {
+            _this.populate(versionOrVendorList);
+            _this.readyPromise = Promise.resolve();
+        } else {
+            if (!url2) {
+                throw new GVLError("must specify GVL.baseUrl before loading GVL json");
+            }
+            if (versionOrVendorList > 0) {
+                var version = versionOrVendorList;
+                if (_GVL.CACHE.has(version)) {
+                    _this.populate(_GVL.CACHE.get(version));
+                    _this.readyPromise = Promise.resolve();
+                } else {
+                    url2 += _GVL.versionedFilename.replace("[VERSION]", String(version));
+                    _this.readyPromise = _this.fetchJson(url2);
+                }
+            } else {
+                if (_GVL.CACHE.has(_GVL.LATEST_CACHE_KEY)) {
+                    _this.populate(_GVL.CACHE.get(_GVL.LATEST_CACHE_KEY));
+                    _this.readyPromise = Promise.resolve();
+                } else {
+                    _this.isLatest = true;
+                    _this.readyPromise = _this.fetchJson(url2 + _GVL.latestFilename);
+                }
+            }
+        }
+        return _this;
+    }
+    _create_class(_GVL, [
+        {
+            key: "cacheLanguage",
+            value: function cacheLanguage() {
+                if (!_GVL.LANGUAGE_CACHE.has(this.lang_)) {
+                    _GVL.LANGUAGE_CACHE.set(this.lang_, {
+                        purposes: this.purposes,
+                        specialPurposes: this.specialPurposes,
+                        features: this.features,
+                        specialFeatures: this.specialFeatures,
+                        stacks: this.stacks
+                    });
+                }
+            }
+        },
+        {
+            key: "fetchJson",
+            value: function fetchJson(url2) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                _ = _this.populate;
+                                return [
+                                    4,
+                                    Json.fetch(url2)
+                                ];
+                            case 1:
+                                _.apply(_this, [
+                                    _state.sent()
+                                ]);
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 2:
+                                err = _state.sent();
+                                throw new GVLError(err.message);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+   * 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.
+   */ key: "getJson",
+            value: function 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,
+                    vendors: this.fullVendorList
+                }));
+            }
+        },
+        {
+            key: "changeLanguage",
+            value: /**
+   * changeLanguage - retrieves the purpose language translation and sets the
+   * internal language variable
+   *
+   * @param {string} lang - ISO 639-1 langauge 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.
+   */ function changeLanguage(lang) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var langUpper, cached, prop, url2, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                langUpper = lang.toUpperCase();
+                                if (!_GVL.consentLanguages.has(langUpper)) return [
+                                    3,
+                                    6
+                                ];
+                                if (!(langUpper !== _this.lang_)) return [
+                                    3,
+                                    5
+                                ];
+                                _this.lang_ = langUpper;
+                                if (!_GVL.LANGUAGE_CACHE.has(langUpper)) return [
+                                    3,
+                                    1
+                                ];
+                                cached = _GVL.LANGUAGE_CACHE.get(langUpper);
+                                for(var prop in cached){
+                                    if (cached.hasOwnProperty(prop)) {
+                                        _this[prop] = cached[prop];
+                                    }
+                                }
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 1:
+                                url2 = _GVL.baseUrl + _GVL.languageFilename.replace("[LANG]", lang);
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    _this.fetchJson(url2)
+                                ];
+                            case 3:
+                                _state.sent();
+                                _this.cacheLanguage();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                err = _state.sent();
+                                throw new GVLError("unable to load language: " + err.message);
+                            case 5:
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 6:
+                                throw new GVLError("unsupported language ".concat(lang));
+                            case 7:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "language",
+            get: function get() {
+                return this.lang_;
+            }
+        },
+        {
+            key: "isVendorList",
+            value: function isVendorList(gvlObject) {
+                return gvlObject !== void 0 && gvlObject.vendors !== void 0;
+            }
+        },
+        {
+            key: "populate",
+            value: function populate(gvlObject) {
+                this.purposes = gvlObject.purposes;
+                this.specialPurposes = gvlObject.specialPurposes;
+                this.features = gvlObject.features;
+                this.specialFeatures = gvlObject.specialFeatures;
+                this.stacks = gvlObject.stacks;
+                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) {
+                        _GVL.CACHE.set(_GVL.LATEST_CACHE_KEY, this.getJson());
+                    }
+                    if (!_GVL.CACHE.has(this.vendorListVersion)) {
+                        _GVL.CACHE.set(this.vendorListVersion, this.getJson());
+                    }
+                }
+                this.cacheLanguage();
+            }
+        },
+        {
+            key: "mapVendors",
+            value: function mapVendors(vendorIds) {
+                var _this = this;
+                this.byPurposeVendorMap = {};
+                this.bySpecialPurposeVendorMap = {};
+                this.byFeatureVendorMap = {};
+                this.bySpecialFeatureVendorMap = {};
+                Object.keys(this.purposes).forEach(function(purposeId) {
+                    _this.byPurposeVendorMap[purposeId] = {
+                        legInt: /* @__PURE__ */ new Set(),
+                        consent: /* @__PURE__ */ new Set(),
+                        flexible: /* @__PURE__ */ new Set()
+                    };
+                });
+                Object.keys(this.specialPurposes).forEach(function(purposeId) {
+                    _this.bySpecialPurposeVendorMap[purposeId] = /* @__PURE__ */ new Set();
+                });
+                Object.keys(this.features).forEach(function(featureId) {
+                    _this.byFeatureVendorMap[featureId] = /* @__PURE__ */ new Set();
+                });
+                Object.keys(this.specialFeatures).forEach(function(featureId) {
+                    _this.bySpecialFeatureVendorMap[featureId] = /* @__PURE__ */ new Set();
+                });
+                if (!Array.isArray(vendorIds)) {
+                    vendorIds = Object.keys(this.fullVendorList).map(function(vId) {
+                        return +vId;
+                    });
+                }
+                this.vendorIds = new Set(vendorIds);
+                this.vendors_ = vendorIds.reduce(function(vendors, vendorId) {
+                    var vendor = _this.vendors_[String(vendorId)];
+                    if (vendor && vendor.deletedDate === void 0) {
+                        vendor.purposes.forEach(function(purposeId) {
+                            var purpGroup = _this.byPurposeVendorMap[String(purposeId)];
+                            purpGroup.consent.add(vendorId);
+                        });
+                        vendor.specialPurposes.forEach(function(purposeId) {
+                            _this.bySpecialPurposeVendorMap[String(purposeId)].add(vendorId);
+                        });
+                        vendor.legIntPurposes.forEach(function(purposeId) {
+                            _this.byPurposeVendorMap[String(purposeId)].legInt.add(vendorId);
+                        });
+                        if (vendor.flexiblePurposes) {
+                            vendor.flexiblePurposes.forEach(function(purposeId) {
+                                _this.byPurposeVendorMap[String(purposeId)].flexible.add(vendorId);
+                            });
+                        }
+                        vendor.features.forEach(function(featureId) {
+                            _this.byFeatureVendorMap[String(featureId)].add(vendorId);
+                        });
+                        vendor.specialFeatures.forEach(function(featureId) {
+                            _this.bySpecialFeatureVendorMap[String(featureId)].add(vendorId);
+                        });
+                        vendors[vendorId] = vendor;
+                    }
+                    return vendors;
+                }, {});
+            }
+        },
+        {
+            key: "getFilteredVendors",
+            value: function getFilteredVendors(purposeOrFeature, id, subType, special) {
+                var _this = this;
+                var properPurposeOrFeature = purposeOrFeature.charAt(0).toUpperCase() + purposeOrFeature.slice(1);
+                var vendorSet;
+                var 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(function(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
+   */ key: "getVendorsWithConsentPurpose",
+            value: function 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
+   */ key: "getVendorsWithLegIntPurpose",
+            value: function 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
+   */ key: "getVendorsWithFlexiblePurpose",
+            value: function 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
+   */ key: "getVendorsWithSpecialPurpose",
+            value: function 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
+   */ key: "getVendorsWithFeature",
+            value: function getVendorsWithFeature(featureId) {
+                return this.getFilteredVendors("feature", featureId);
+            }
+        },
+        {
+            /**
+   * getVendorsWithSpecialFeature
+   *
+   * @param {number} specialFeatureId
+   * @return {IntMap<Vendor>} - list of vendors that have declared the special feature id
+   */ key: "getVendorsWithSpecialFeature",
+            value: function getVendorsWithSpecialFeature(specialFeatureId) {
+                return this.getFilteredVendors("feature", specialFeatureId, void 0, true);
+            }
+        },
+        {
+            key: "vendors",
+            get: /**
+   * 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
+   */ function get() {
+                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}
+   */ key: "narrowVendorsTo",
+            value: function narrowVendorsTo(vendorIds) {
+                this.mapVendors(vendorIds);
+            }
+        },
+        {
+            key: "isReady",
+            get: /**
+   * 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
+   */ function get() {
+                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}
+   */ key: "clone",
+            value: function clone() {
+                var result = new _GVL(this.getJson());
+                if (this.lang_ !== _GVL.DEFAULT_LANGUAGE) {
+                    result.changeLanguage(this.lang_);
+                }
+                return result;
+            }
+        }
+    ], [
+        {
+            key: "baseUrl",
+            get: /**
+   * 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`
+   */ function get() {
+                return this.baseUrl_;
+            },
+            set: /**
+   * 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)
+   */ function set(url2) {
+                var notValid = /^https?:\/\/vendorlist\.consensu\.org\//;
+                if (notValid.test(url2)) {
+                    throw new GVLError("Invalid baseUrl!  You may not pull directly from vendorlist.consensu.org and must provide your own cache");
+                }
+                if (url2.length > 0 && url2[url2.length - 1] !== "/") {
+                    url2 += "/";
+                }
+                this.baseUrl_ = url2;
+            }
+        },
+        {
+            key: "emptyLanguageCache",
+            value: /**
+   * emptyLanguageCache
+   *
+   * @param {string} [lang] - Optional ISO 639-1 langauge 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
+   */ function emptyLanguageCache(lang) {
+                var retr = false;
+                if (lang === void 0 && _GVL.LANGUAGE_CACHE.size > 0) {
+                    _GVL.LANGUAGE_CACHE = /* @__PURE__ */ new Map();
+                    retr = true;
+                } else if (typeof lang === "string" && this.consentLanguages.has(lang.toUpperCase())) {
+                    _GVL.LANGUAGE_CACHE.delete(lang.toUpperCase());
+                    retr = true;
+                }
+                return retr;
+            }
+        },
+        {
+            key: "emptyCache",
+            value: /**
+   * 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
+   */ function emptyCache(vendorListVersion) {
+                var retr = false;
+                if (Number.isInteger(vendorListVersion) && vendorListVersion >= 0) {
+                    _GVL.CACHE.delete(vendorListVersion);
+                    retr = true;
+                } else if (vendorListVersion === void 0) {
+                    _GVL.CACHE = /* @__PURE__ */ new Map();
+                    retr = true;
+                }
+                return retr;
+            }
+        },
+        {
+            key: "isInstanceOf",
+            value: function isInstanceOf(questionableInstance) {
+                var isSo = typeof questionableInstance === "object";
+                return isSo && typeof questionableInstance.narrowVendorsTo === "function";
+            }
+        }
+    ]);
+    return _GVL;
+}(Cloneable);
+__publicField(_GVL, "LANGUAGE_CACHE", /* @__PURE__ */ new Map());
+__publicField(_GVL, "CACHE", /* @__PURE__ */ new Map());
+__publicField(_GVL, "LATEST_CACHE_KEY", 0);
+__publicField(_GVL, "DEFAULT_LANGUAGE", "EN");
+/**
+ * Set of available consent languages published by the IAB
+ */ __publicField(_GVL, "consentLanguages", new ConsentLanguages());
+__publicField(_GVL, "baseUrl_");
+/**
+ * @static
+ * @param {string} - the latest is assumed to be vendor-list.json because
+ * that is what the iab uses, but it could be different... if you want
+ */ __publicField(_GVL, "latestFilename", "vendor-list.json");
+/**
+ * @static
+ * @param {string} - the versioned name is assumed to be
+ * vendor-list-v[VERSION].json where [VERSION] will be replaced with the
+ * specified version.  But it could be different... if you want just make
+ * sure to include the [VERSION] macro if you have a numbering scheme, it's a
+ * simple string substitution.
+ *
+ * eg.
+ * ```javascript
+ * GVL.baseUrl = "http://www.mydomain.com/iabcmp/";
+ * GVL.versionedFilename = "vendorlist?getVersion=[VERSION]";
+ * ```
+ */ __publicField(_GVL, "versionedFilename", "archives/vendor-list-v[VERSION].json");
+/**
+ * @param {string} - Translations of the names and descriptions for Purposes,
+ * Special Purposes, Features, and Special Features to non-English languages
+ * are contained in a file where attributes containing English content
+ * (except vendor declaration information) are translated.  The iab publishes
+ * one following the scheme below where the LANG is the iso639-1 language
+ * code.  For a list of available translations
+ * [please go here](https://register.consensu.org/Translation).
+ *
+ * eg.
+ * ```javascript
+ * GVL.baseUrl = "http://www.mydomain.com/iabcmp/";
+ * GVL.languageFilename = "purposes?getPurposes=[LANG]";
+ * ```
+ */ __publicField(_GVL, "languageFilename", "purposes-[LANG].json");
+var GVL = _GVL;
+// node_modules/@iabtcf/core/lib/mjs/TCModel.js
+var TCModel = /*#__PURE__*/ function(Cloneable) {
+    "use strict";
+    _inherits(TCModel, Cloneable);
+    var _super = _create_super(TCModel);
+    function TCModel(gvl) {
+        _class_call_check(this, TCModel);
+        var _this;
+        _this = _super.call(this);
+        __publicField(_assert_this_initialized(_this), "isServiceSpecific_", false);
+        __publicField(_assert_this_initialized(_this), "supportOOB_", true);
+        __publicField(_assert_this_initialized(_this), "useNonStandardStacks_", false);
+        __publicField(_assert_this_initialized(_this), "purposeOneTreatment_", false);
+        __publicField(_assert_this_initialized(_this), "publisherCountryCode_", "AA");
+        __publicField(_assert_this_initialized(_this), "version_", 2);
+        __publicField(_assert_this_initialized(_this), "consentScreen_", 0);
+        __publicField(_assert_this_initialized(_this), "policyVersion_", 2);
+        __publicField(_assert_this_initialized(_this), "consentLanguage_", "EN");
+        __publicField(_assert_this_initialized(_this), "cmpId_", 0);
+        __publicField(_assert_this_initialized(_this), "cmpVersion_", 0);
+        __publicField(_assert_this_initialized(_this), "vendorListVersion_", 0);
+        __publicField(_assert_this_initialized(_this), "numCustomPurposes_", 0);
+        // Member Variable for GVL
+        __publicField(_assert_this_initialized(_this), "gvl_");
+        __publicField(_assert_this_initialized(_this), "created");
+        __publicField(_assert_this_initialized(_this), "lastUpdated");
+        /**
+     * The TCF designates certain Features as special, that is, a CMP must afford
+     * the user a means to opt in to their use. These Special Features are
+     * published and numbered in the GVL separately from normal Features.
+     * Provides for up to 12 special features.
+     */ __publicField(_assert_this_initialized(_this), "specialFeatureOptins", new Vector());
+        /**
+     * Renamed from `PurposesAllowed` in TCF v1.1
+     * The user’s consent value for each Purpose established on the legal basis
+     * of consent. Purposes are published in the Global Vendor List (see. [[GVL]]).
+     */ __publicField(_assert_this_initialized(_this), "purposeConsents", new Vector());
+        /**
+     * The user’s permission for each Purpose established on the legal basis of
+     * legitimate interest. If the user has exercised right-to-object for a
+     * purpose.
+     */ __publicField(_assert_this_initialized(_this), "purposeLegitimateInterests", new Vector());
+        /**
+     * The user’s consent value for each Purpose established on the legal basis
+     * of consent, for the publisher.  Purposes are published in the Global
+     * Vendor List.
+     */ __publicField(_assert_this_initialized(_this), "publisherConsents", new Vector());
+        /**
+     * The user’s permission for each Purpose established on the legal basis of
+     * legitimate interest.  If the user has exercised right-to-object for a
+     * purpose.
+     */ __publicField(_assert_this_initialized(_this), "publisherLegitimateInterests", new Vector());
+        /**
+     * The user’s consent value for each Purpose established on the legal basis
+     * of consent, for the publisher.  Purposes are published in the Global
+     * Vendor List.
+     */ __publicField(_assert_this_initialized(_this), "publisherCustomConsents", new Vector());
+        /**
+     * The user’s permission for each Purpose established on the legal basis of
+     * legitimate interest.  If the user has exercised right-to-object for a
+     * purpose that is established in the publisher's custom purposes.
+     */ __publicField(_assert_this_initialized(_this), "publisherCustomLegitimateInterests", new Vector());
+        /**
+     * set by a publisher if they wish to collect consent and LI Transparency for
+     * purposes outside of the TCF
+     */ __publicField(_assert_this_initialized(_this), "customPurposes");
+        /**
+     * Each [[Vendor]] is keyed by id. Their consent value is true if it is in
+     * the Vector
+     */ __publicField(_assert_this_initialized(_this), "vendorConsents", new Vector());
+        /**
+     * Each [[Vendor]] is keyed by id. Whether their Legitimate Interests
+     * Disclosures have been established is stored as boolean.
+     * see: [[Vector]]
+     */ __publicField(_assert_this_initialized(_this), "vendorLegitimateInterests", new Vector());
+        /**
+     * The value included for disclosed vendors signals which vendors have been
+     * disclosed to the user in the interface surfaced by the CMP. This section
+     * content is required when writing a TC string to the global (consensu)
+     * scope. When a CMP has read from and is updating a TC string from the
+     * global consensu.org storage, the CMP MUST retain the existing disclosure
+     * information and only add information for vendors that it has disclosed
+     * that had not been disclosed by other CMPs in prior interactions with this
+     * device/user agent.
+     */ __publicField(_assert_this_initialized(_this), "vendorsDisclosed", new Vector());
+        /**
+     * Signals which vendors the publisher permits to use OOB legal bases.
+     */ __publicField(_assert_this_initialized(_this), "vendorsAllowed", new Vector());
+        __publicField(_assert_this_initialized(_this), "publisherRestrictions", new PurposeRestrictionVector());
+        if (gvl) {
+            _this.gvl = gvl;
+        }
+        _this.updated();
+        return _this;
+    }
+    _create_class(TCModel, [
+        {
+            key: "gvl",
+            get: /**
+   * @return {GVL} the gvl instance set on this TCModel instance
+   */ function get() {
+                return this.gvl_;
+            },
+            set: /**
+   * sets the [[GVL]] with side effects of also setting the `vendorListVersion`, `policyVersion`, and `consentLanguage`
+   * @param {GVL} gvl
+   */ function set(gvl) {
+                if (!GVL.isInstanceOf(gvl)) {
+                    gvl = new GVL(gvl);
+                }
+                this.gvl_ = gvl;
+                this.publisherRestrictions.gvl = gvl;
+            }
+        },
+        {
+            key: "cmpId",
+            get: function get() {
+                return this.cmpId_;
+            },
+            set: /**
+   * @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.
+   */ function set(integer) {
+                integer = Number(integer);
+                if (Number.isInteger(integer) && integer > 1) {
+                    this.cmpId_ = integer;
+                } else {
+                    throw new TCModelError("cmpId", integer);
+                }
+            }
+        },
+        {
+            key: "cmpVersion",
+            get: function get() {
+                return this.cmpVersion_;
+            },
+            set: /**
+   * 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.
+   */ function set(integer) {
+                integer = Number(integer);
+                if (Number.isInteger(integer) && integer > -1) {
+                    this.cmpVersion_ = integer;
+                } else {
+                    throw new TCModelError("cmpVersion", integer);
+                }
+            }
+        },
+        {
+            key: "consentScreen",
+            get: function get() {
+                return this.consentScreen_;
+            },
+            set: /**
+   * 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.
+   */ function set(integer) {
+                integer = Number(integer);
+                if (Number.isInteger(integer) && integer > -1) {
+                    this.consentScreen_ = integer;
+                } else {
+                    throw new TCModelError("consentScreen", integer);
+                }
+            }
+        },
+        {
+            key: "consentLanguage",
+            get: function get() {
+                return this.consentLanguage_;
+            },
+            set: /**
+   * @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
+   */ function set(lang) {
+                this.consentLanguage_ = lang;
+            }
+        },
+        {
+            key: "publisherCountryCode",
+            get: function get() {
+                return this.publisherCountryCode_;
+            },
+            set: /**
+   * @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
+   */ function set(countryCode) {
+                if (/^([A-z]){2}$/.test(countryCode)) {
+                    this.publisherCountryCode_ = countryCode.toUpperCase();
+                } else {
+                    throw new TCModelError("publisherCountryCode", countryCode);
+                }
+            }
+        },
+        {
+            key: "vendorListVersion",
+            get: function get() {
+                if (this.gvl) {
+                    return this.gvl.vendorListVersion;
+                } else {
+                    return this.vendorListVersion_;
+                }
+            },
+            set: /**
+   * 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.
+   */ function set(integer) {
+                integer = Number(integer) >> 0;
+                if (integer < 0) {
+                    throw new TCModelError("vendorListVersion", integer);
+                } else {
+                    this.vendorListVersion_ = integer;
+                }
+            }
+        },
+        {
+            key: "policyVersion",
+            get: function get() {
+                if (this.gvl) {
+                    return this.gvl.tcfPolicyVersion;
+                } else {
+                    return this.policyVersion_;
+                }
+            },
+            set: /**
+   * 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]].
+   *
+   */ function set(num) {
+                this.policyVersion_ = parseInt(num, 10);
+                if (this.policyVersion_ < 0) {
+                    throw new TCModelError("policyVersion", num);
+                }
+            }
+        },
+        {
+            key: "version",
+            get: function get() {
+                return this.version_;
+            },
+            set: function set(num) {
+                this.version_ = parseInt(num, 10);
+            }
+        },
+        {
+            key: "isServiceSpecific",
+            get: function get() {
+                return this.isServiceSpecific_;
+            },
+            set: /**
+   * 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.
+   */ function set(bool) {
+                this.isServiceSpecific_ = bool;
+            }
+        },
+        {
+            key: "useNonStandardStacks",
+            get: function get() {
+                return this.useNonStandardStacks_;
+            },
+            set: /**
+   * 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
+   */ function set(bool) {
+                this.useNonStandardStacks_ = bool;
+            }
+        },
+        {
+            key: "supportOOB",
+            get: function get() {
+                return this.supportOOB_;
+            },
+            set: /**
+   * 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
+   */ function set(bool) {
+                this.supportOOB_ = bool;
+            }
+        },
+        {
+            key: "purposeOneTreatment",
+            get: function get() {
+                return this.purposeOneTreatment_;
+            },
+            set: /**
+   * `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
+   */ function set(bool) {
+                this.purposeOneTreatment_ = bool;
+            }
+        },
+        {
+            /**
+   * setAllVendorConsents - sets all vendors on the GVL Consent (true)
+   *
+   * @return {void}
+   */ key: "setAllVendorConsents",
+            value: function setAllVendorConsents() {
+                this.vendorConsents.set(this.gvl.vendors);
+            }
+        },
+        {
+            /**
+   * unsetAllVendorConsents - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */ key: "unsetAllVendorConsents",
+            value: function unsetAllVendorConsents() {
+                this.vendorConsents.empty();
+            }
+        },
+        {
+            /**
+   * setAllVendorsDisclosed - sets all vendors on the GVL Vendors Disclosed (true)
+   *
+   * @return {void}
+   */ key: "setAllVendorsDisclosed",
+            value: function setAllVendorsDisclosed() {
+                this.vendorsDisclosed.set(this.gvl.vendors);
+            }
+        },
+        {
+            /**
+   * unsetAllVendorsDisclosed - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */ key: "unsetAllVendorsDisclosed",
+            value: function unsetAllVendorsDisclosed() {
+                this.vendorsDisclosed.empty();
+            }
+        },
+        {
+            /**
+   * setAllVendorsAllowed - sets all vendors on the GVL Consent (true)
+   *
+   * @return {void}
+   */ key: "setAllVendorsAllowed",
+            value: function setAllVendorsAllowed() {
+                this.vendorsAllowed.set(this.gvl.vendors);
+            }
+        },
+        {
+            /**
+   * unsetAllVendorsAllowed - unsets all vendors on the GVL Consent (false)
+   *
+   * @return {void}
+   */ key: "unsetAllVendorsAllowed",
+            value: function unsetAllVendorsAllowed() {
+                this.vendorsAllowed.empty();
+            }
+        },
+        {
+            /**
+   * setAllVendorLegitimateInterests - sets all vendors on the GVL LegitimateInterests (true)
+   *
+   * @return {void}
+   */ key: "setAllVendorLegitimateInterests",
+            value: function setAllVendorLegitimateInterests() {
+                this.vendorLegitimateInterests.set(this.gvl.vendors);
+            }
+        },
+        {
+            /**
+   * unsetAllVendorLegitimateInterests - unsets all vendors on the GVL LegitimateInterests (false)
+   *
+   * @return {void}
+   */ key: "unsetAllVendorLegitimateInterests",
+            value: function unsetAllVendorLegitimateInterests() {
+                this.vendorLegitimateInterests.empty();
+            }
+        },
+        {
+            /**
+   * setAllPurposeConsents - sets all purposes on the GVL Consent (true)
+   *
+   * @return {void}
+   */ key: "setAllPurposeConsents",
+            value: function setAllPurposeConsents() {
+                this.purposeConsents.set(this.gvl.purposes);
+            }
+        },
+        {
+            /**
+   * unsetAllPurposeConsents - unsets all purposes on the GVL Consent (false)
+   *
+   * @return {void}
+   */ key: "unsetAllPurposeConsents",
+            value: function unsetAllPurposeConsents() {
+                this.purposeConsents.empty();
+            }
+        },
+        {
+            /**
+   * setAllPurposeLegitimateInterests - sets all purposes on the GVL LI Transparency (true)
+   *
+   * @return {void}
+   */ key: "setAllPurposeLegitimateInterests",
+            value: function setAllPurposeLegitimateInterests() {
+                this.purposeLegitimateInterests.set(this.gvl.purposes);
+            }
+        },
+        {
+            /**
+   * unsetAllPurposeLegitimateInterests - unsets all purposes on the GVL LI Transparency (false)
+   *
+   * @return {void}
+   */ key: "unsetAllPurposeLegitimateInterests",
+            value: function unsetAllPurposeLegitimateInterests() {
+                this.purposeLegitimateInterests.empty();
+            }
+        },
+        {
+            /**
+   * setAllSpecialFeatureOptins - sets all special featuresOptins on the GVL (true)
+   *
+   * @return {void}
+   */ key: "setAllSpecialFeatureOptins",
+            value: function setAllSpecialFeatureOptins() {
+                this.specialFeatureOptins.set(this.gvl.specialFeatures);
+            }
+        },
+        {
+            /**
+   * unsetAllSpecialFeatureOptins - unsets all special featuresOptins on the GVL (true)
+   *
+   * @return {void}
+   */ key: "unsetAllSpecialFeatureOptins",
+            value: function unsetAllSpecialFeatureOptins() {
+                this.specialFeatureOptins.empty();
+            }
+        },
+        {
+            key: "setAll",
+            value: function setAll() {
+                this.setAllVendorConsents();
+                this.setAllPurposeLegitimateInterests();
+                this.setAllSpecialFeatureOptins();
+                this.setAllPurposeConsents();
+                this.setAllVendorLegitimateInterests();
+            }
+        },
+        {
+            key: "unsetAll",
+            value: function unsetAll() {
+                this.unsetAllVendorConsents();
+                this.unsetAllPurposeLegitimateInterests();
+                this.unsetAllSpecialFeatureOptins();
+                this.unsetAllPurposeConsents();
+                this.unsetAllVendorLegitimateInterests();
+            }
+        },
+        {
+            key: "numCustomPurposes",
+            get: function get() {
+                var len = this.numCustomPurposes_;
+                if (typeof this.customPurposes === "object") {
+                    var purposeIds = Object.keys(this.customPurposes).sort(function(a, b) {
+                        return Number(a) - Number(b);
+                    });
+                    len = parseInt(purposeIds.pop(), 10);
+                }
+                return len;
+            },
+            set: function set(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}
+   */ key: "updated",
+            value: function updated() {
+                var date = /* @__PURE__ */ new Date();
+                var utcDate = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+                this.created = utcDate;
+                this.lastUpdated = utcDate;
+            }
+        }
+    ]);
+    return TCModel;
+}(Cloneable);
+/**
+ * Set of available consent languages published by the IAB
+ */ __publicField(TCModel, "consentLanguages", GVL.consentLanguages);
+// node_modules/@iabtcf/core/lib/mjs/TCString.js
+var TCString = /*#__PURE__*/ function() {
+    "use strict";
+    function TCString() {
+        _class_call_check(this, TCString);
+    }
+    _create_class(TCString, null, [
+        {
+            key: "encode",
+            value: /**
+   * 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
+   */ function encode(tcModel, options) {
+                var out = "";
+                var sequence;
+                tcModel = SemanticPreEncoder.process(tcModel, options);
+                if (Array.isArray(options === null || options === void 0 ? void 0 : options.segments)) {
+                    sequence = options.segments;
+                } else {
+                    sequence = new SegmentSequence(tcModel, options)["" + tcModel.version];
+                }
+                sequence.forEach(function(segment, idx) {
+                    var dotMaybe = "";
+                    if (idx < sequence.length - 1) {
+                        dotMaybe = ".";
+                    }
+                    out += SegmentEncoder.encode(tcModel, segment) + dotMaybe;
+                });
+                return out;
+            }
+        },
+        {
+            key: "decode",
+            value: /**
+   * 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
+   */ function decode(encodedTCString, tcModel) {
+                var segments = encodedTCString.split(".");
+                var len = segments.length;
+                if (!tcModel) {
+                    tcModel = new TCModel();
+                }
+                for(var i2 = 0; i2 < len; i2++){
+                    var segString = segments[i2];
+                    var firstChar = Base64Url.decode(segString.charAt(0));
+                    var segTypeBits = firstChar.substr(0, BitLength.segmentType);
+                    var segment = SegmentIDs.ID_TO_KEY[IntEncoder.decode(segTypeBits, BitLength.segmentType).toString()];
+                    SegmentEncoder.decode(segString, tcModel, segment);
+                }
+                return tcModel;
+            }
+        }
+    ]);
+    return TCString;
+}();
+// src/Ads/Providers/SmartyAds/SmartyAdsSDK.ts
+GVL.baseUrl = "https://vendor-list.consensu.org/v3/";
+var PARAMS = [
+    "res",
+    "m",
+    "ua",
+    "ip",
+    "w",
+    "h",
+    "gdpr",
+    "gdpr_consent",
+    "gpp",
+    "gpp_sid",
+    "coppa",
+    "page",
+    "domain",
+    "secure",
+    "lmt",
+    "dnt",
+    "ad_width",
+    "ad_height",
+    "language",
+    "cattax",
+    "keywords",
+    "placementId"
+];
+var SmartyadsSDK = /*#__PURE__*/ function() {
+    "use strict";
+    function SmartyadsSDK() {
+        _class_call_check(this, SmartyadsSDK);
+    }
+    _create_class(SmartyadsSDK, [
+        {
+            key: "generateTCString",
+            value: function generateTCString() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var tcModel;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!!_this.gdprConsent) return [
+                                    3,
+                                    2
+                                ];
+                                tcModel = new TCModel(new GVL());
+                                tcModel.vendorConsents.set(534);
+                                return [
+                                    4,
+                                    tcModel.gvl.readyPromise
+                                ];
+                            case 1:
+                                _state.sent();
+                                _this.gdprConsent = TCString.encode(tcModel);
+                                console.log(_this.gdprConsent);
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    2,
+                                    _this.gdprConsent
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "buildQueryParams",
+            value: /**
+   * Converts an object into a URL query string.
+   *
+   * @param params - The object to be converted into query parameters.
+   * @returns The query string with URL encoding.
+   */ function buildQueryParams(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var queryString;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!(params.gdpr === void 0)) return [
+                                    3,
+                                    2
+                                ];
+                                params.gdpr = 1;
+                                return [
+                                    4,
+                                    _this.generateTCString()
+                                ];
+                            case 1:
+                                params.gdpr_consent = _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                queryString = PARAMS.map(function(key) {
+                                    var value2 = params[key];
+                                    if (value2 === null || value2 === void 0) {
+                                        return "";
+                                    }
+                                    return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value2));
+                                }).filter(function(part) {
+                                    return part.length > 0;
+                                }).join("&");
+                                return [
+                                    2,
+                                    queryString
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "request",
+            value: function request(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _, _1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _1 = (_ = "https://n1.smartyads.com/?c=b&").concat;
+                                return [
+                                    4,
+                                    _this.buildQueryParams(params)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    fetch.apply(void 0, [
+                                        _1.apply(_, [
+                                            _state.sent()
+                                        ])
+                                    ]).then(function(response) {
+                                        if (!response.ok) {
+                                            throw new InternalError("Network response was not ok");
+                                        }
+                                        return response.json();
+                                    }).then(function(data) {
+                                        return data;
+                                    }).catch(function(error) {
+                                        throw error;
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return SmartyadsSDK;
+}();
+// src/Ads/Providers/SmartyAds/SmartyadsProvider.ts
+var SmartyadsProvider = /*#__PURE__*/ function(ContentProvider) {
+    "use strict";
+    _inherits(SmartyadsProvider, ContentProvider);
+    var _super = _create_super(SmartyadsProvider);
+    function SmartyadsProvider(context, options) {
+        _class_call_check(this, SmartyadsProvider);
+        var _this;
+        _this = _super.call(this, context, options);
+        _this.placements = options.placements || {};
+        _this.smartyads = new SmartyadsSDK();
+        return _this;
+    }
+    _create_class(SmartyadsProvider, [
+        {
+            key: "getPlacement",
+            value: function getPlacement(regionId) {
+                var availablePlacements = Object.keys(this.placements).map(parseInt);
+                if (!availablePlacements.length) {
+                    throw new Error("No available placements!");
+                }
+                var foundPlacement;
+                if (!regionId) {
+                    foundPlacement = this.placements[availablePlacements[0]];
+                } else {
+                    foundPlacement = this.placements[regionId];
+                }
+                if (typeof foundPlacement === "number") {
+                    return {
+                        id: foundPlacement
+                    };
+                }
+                return foundPlacement;
+            }
+        },
+        {
+            key: "request",
+            value: function request(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _params_params, placementInfo, smartyadsContent, div, index;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!params || params.size.width === void 0 || params.size.width === 0 || params.size.height === void 0 || params.size.height === 0) {
+                                    throw new InternalError("No Params!");
+                                }
+                                placementInfo = _this.getPlacement((_params_params = params.params) === null || _params_params === void 0 ? void 0 : _params_params.regionId);
+                                return [
+                                    4,
+                                    _this.smartyads.request(_object_spread_props(_object_spread({}, _this.options), {
+                                        ad_width: placementInfo.w || params.size.width,
+                                        ad_height: placementInfo.h || params.size.height,
+                                        m: "api",
+                                        ua: _this.context.info.ua || navigator.userAgent,
+                                        w: window.innerWidth,
+                                        h: window.innerHeight,
+                                        domain: _this.context.info.domain || window.location.hostname,
+                                        page: window.location.href,
+                                        ip: _this.context.info.ip,
+                                        placementId: placementInfo.id
+                                    }))
                                 ];
                             case 1:
                                 smartyadsContent = _state.sent();
@@ -21573,25 +24944,25 @@ function _iterableToArray(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 function _iterableToArrayLimit(arr, i2) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
+    var _i2 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i2 == null) return;
     var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
+    var _n2 = true;
+    var _d2 = false;
+    var _s, _e2;
     try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+        for(_i2 = _i2.call(arr); !(_n2 = (_s = _i2.next()).done); _n2 = true){
             _arr.push(_s.value);
             if (i2 && _arr.length === i2) break;
         }
     } catch (err) {
-        _d = true;
-        _e = err;
+        _d2 = true;
+        _e2 = err;
     } finally{
         try {
-            if (!_n && _i["return"] != null) _i["return"]();
+            if (!_n2 && _i2["return"] != null) _i2["return"]();
         } finally{
-            if (_d) throw _e;
+            if (_d2) throw _e2;
         }
     }
     return _arr;
@@ -26098,7 +29469,7 @@ var Request2 = /*#__PURE__*/ function(Emitter) {
    */ key: "create",
             value: function create() {
                 var _this = this;
-                var _a;
+                var _a2;
                 var opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
                 opts.xdomain = !!this.opts.xd;
                 var xhr = this.xhr = new XHR(opts);
@@ -26122,7 +29493,7 @@ var Request2 = /*#__PURE__*/ function(Emitter) {
                     try {
                         xhr.setRequestHeader("Accept", "*/*");
                     } catch (e2) {}
-                    (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
+                    (_a2 = this.opts.cookieJar) === null || _a2 === void 0 ? void 0 : _a2.addCookies(xhr);
                     if ("withCredentials" in xhr) {
                         xhr.withCredentials = this.opts.withCredentials;
                     }
@@ -26130,9 +29501,9 @@ var Request2 = /*#__PURE__*/ function(Emitter) {
                         xhr.timeout = this.opts.requestTimeout;
                     }
                     xhr.onreadystatechange = function() {
-                        var _a2;
+                        var _a3;
                         if (xhr.readyState === 3) {
-                            (_a2 = _this.opts.cookieJar) === null || _a2 === void 0 ? void 0 : _a2.parseCookies(xhr);
+                            (_a3 = _this.opts.cookieJar) === null || _a3 === void 0 ? void 0 : _a3.parseCookies(xhr);
                         }
                         if (4 !== xhr.readyState) return;
                         if (200 === xhr.status || 1223 === xhr.status) {
@@ -26483,8 +29854,8 @@ var WT = /*#__PURE__*/ function(Transport) {
         {
             key: "doClose",
             value: function doClose() {
-                var _a;
-                (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+                var _a2;
+                (_a2 = this.transport) === null || _a2 === void 0 ? void 0 : _a2.close();
             }
         }
     ]);
@@ -27761,8 +31132,8 @@ var Socket2 = /*#__PURE__*/ function(Emitter) {
             value: function _registerAckCallback(id, ack) {
                 var _this = this;
                 var _this1 = this;
-                var _a;
-                var timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
+                var _a2;
+                var timeout = (_a2 = this.flags.timeout) !== null && _a2 !== void 0 ? _a2 : this._opts.ackTimeout;
                 if (timeout === void 0) {
                     this.acks[id] = ack;
                     return;
@@ -28518,7 +31889,7 @@ var Manager = /*#__PURE__*/ function(Emitter) {
     function Manager(uri, opts) {
         _class_call_check(this, Manager);
         var _this;
-        var _a;
+        var _a2;
         _this = _super.call(this);
         _this.nsps = {};
         _this.subs = [];
@@ -28534,7 +31905,7 @@ var Manager = /*#__PURE__*/ function(Emitter) {
         _this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
         _this.reconnectionDelay(opts.reconnectionDelay || 1e3);
         _this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3);
-        _this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
+        _this.randomizationFactor((_a2 = opts.randomizationFactor) !== null && _a2 !== void 0 ? _a2 : 0.5);
         _this.backoff = new Backoff({
             min: _this.reconnectionDelay(),
             max: _this.reconnectionDelayMax(),
@@ -28570,30 +31941,30 @@ var Manager = /*#__PURE__*/ function(Emitter) {
         {
             key: "reconnectionDelay",
             value: function reconnectionDelay(v) {
-                var _a;
+                var _a2;
                 if (v === void 0) return this._reconnectionDelay;
                 this._reconnectionDelay = v;
-                (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
+                (_a2 = this.backoff) === null || _a2 === void 0 ? void 0 : _a2.setMin(v);
                 return this;
             }
         },
         {
             key: "randomizationFactor",
             value: function randomizationFactor(v) {
-                var _a;
+                var _a2;
                 if (v === void 0) return this._randomizationFactor;
                 this._randomizationFactor = v;
-                (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
+                (_a2 = this.backoff) === null || _a2 === void 0 ? void 0 : _a2.setJitter(v);
                 return this;
             }
         },
         {
             key: "reconnectionDelayMax",
             value: function reconnectionDelayMax(v) {
-                var _a;
+                var _a2;
                 if (v === void 0) return this._reconnectionDelayMax;
                 this._reconnectionDelayMax = v;
-                (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
+                (_a2 = this.backoff) === null || _a2 === void 0 ? void 0 : _a2.setMax(v);
                 return this;
             }
         },
@@ -30256,7 +33627,7 @@ var BrndtsAds = /*#__PURE__*/ function() {
                     }
                 } catch (error) {
                     if (_instanceof(error, Error)) {
-                        ErrorHandler.handle(error);
+                        this.context.logger.warn("Setup failed: no media element found!");
                     }
                 }
             }