@osano/osano-cmp-react-native 0.1.0

package/lib/commonjs/iab/gpp/encoders/DatetimeEncoder.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encode = exports.default = exports.decode = void 0;
+var _FixedIntegerEncoder = require("./FixedIntegerEncoder");
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/DatetimeEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+const encode = (date, numBits = 36) => {
+  let deciseconds;
+  if (date instanceof Date) {
+    deciseconds = Math.round(date.getTime() / 100);
+  } else {
+    deciseconds = date;
+  }
+  return (0, _FixedIntegerEncoder.encode)(deciseconds, numBits);
+};
+exports.encode = encode;
+const decode = bitString => {
+  const date = new Date((0, _FixedIntegerEncoder.decode)(bitString) * 100);
+  return date;
+};
+exports.decode = decode;
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=DatetimeEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/DatetimeEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FixedIntegerEncoder","require","encode","date","numBits","deciseconds","Date","Math","round","getTime","intEncode","exports","decode","bitString","intDecode","_default","default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/DatetimeEncoder.ts"],"mappings":";;;;;;AAqBA,IAAAA,oBAAA,GAAAC,OAAA;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOO,MAAMC,MAAM,GAAGA,CAACC,IAAmB,EAAEC,OAAe,GAAG,EAAE,KAAK;EACpE,IAAIC,WAAmB;EACvB,IAAIF,IAAI,YAAYG,IAAI,EAAE;IACzBD,WAAW,GAAGE,IAAI,CAACC,KAAK,CAACL,IAAI,CAACM,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC;EAC/C,CAAC,MAAM;IACNJ,WAAW,GAAGF,IAAI;EACnB;EACA,OAAO,IAAAO,2BAAS,EAACL,WAAW,EAAED,OAAO,CAAC;AACvC,CAAC;AAACO,OAAA,CAAAT,MAAA,GAAAA,MAAA;AAEK,MAAMU,MAAM,GAAIC,SAAiB,IAAK;EAC5C,MAAMV,IAAI,GAAG,IAAIG,IAAI,CAAC,IAAAQ,2BAAS,EAACD,SAAS,CAAC,GAAG,GAAG,CAAC;EAEjD,OAAOV,IAAI;AACZ,CAAC;AAACQ,OAAA,CAAAC,MAAA,GAAAA,MAAA;AAAA,IAAAG,QAAA,GAAAJ,OAAA,CAAAK,OAAA,GAEa;EACdJ,MAAM;EACNV;AACD,CAAC","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/EncodableOptimizedFixedRange.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.BitLength = void 0;
+var _BooleanEncoder = _interopRequireDefault(require("./BooleanEncoder"));
+var _FixedIdBitMapEncoder = _interopRequireDefault(require("./FixedIdBitMapEncoder"));
+var _FixedIntegerEncoder = _interopRequireDefault(require("./FixedIntegerEncoder"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This is our own implementation but is analogous to
+// https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/EncodableOptimizedFixedRange.ts
+
+const BitLength = exports.BitLength = {
+  encodingType: 1,
+  maxId: 16,
+  numEntries: 12,
+  singleOrRange: 1,
+  vendorId: 16
+};
+const HEADER_LENGTH = BitLength.maxId + BitLength.encodingType;
+const RANGE_MINIMUM_LENGTH = BitLength.vendorId + BitLength.singleOrRange + BitLength.numEntries;
+const ENCODING_TYPE = {
+  FIELD: 0,
+  RANGE: 1
+};
+const buildRangeEncoding = ranges => {
+  // describe the number of entries to follow
+  const numEntries = ranges.length;
+  let rangeString = _FixedIntegerEncoder.default.encode(numEntries, BitLength.numEntries);
+
+  // each range
+  ranges.forEach((range /*: number[]*/) => {
+    // is this range a single?
+    const single = range.length === 1;
+
+    // first is the indicator of whether this is a single id or range (two)
+    // 0 is single and range is 1
+    rangeString += _BooleanEncoder.default.encode(!single);
+
+    // second is the first (or only) vendorId
+    rangeString += _FixedIntegerEncoder.default.encode(`${range[0]}`, BitLength.vendorId);
+    if (!single) {
+      // add the second id if it exists
+      rangeString += _FixedIntegerEncoder.default.encode(`${range[1]}`, BitLength.vendorId);
+    }
+  });
+  return rangeString;
+};
+const encode = value => {
+  // Filter out any falsey values and convert the keys to numbers
+  const vendorIds = Object.entries(value).filter(([, v]) => !!v).map(([id]) => {
+    const parsedId = parseInt(id, 10);
+    if (isNaN(parsedId) || parsedId < 1 || /^\d+$/.test(id) === false) {
+      throw new Error(`Invalid vendor ID: ${id}`);
+    }
+    return parsedId;
+  });
+  const vendorSet = new Set(vendorIds);
+  const maxId = Math.max(0, ...vendorIds);
+  // collectors for range encoding
+  const ranges = []; // : number[][]
+  let range = []; // : number[]
+
+  // bit field will be just the encoded value of the ID corresponding to the
+  // position in the bit field
+  let bitField = '';
+  // A range is a minimum of 29 bits, so if the max vendor ID in this value
+  // is less than that then we know that a bitfield encoding will be shorter
+  // than any range encoding.
+  let rangeIsSmaller = maxId > RANGE_MINIMUM_LENGTH;
+  const bitFieldLength = HEADER_LENGTH + maxId;
+
+  // grows as we add to the range
+  let rangeLength = HEADER_LENGTH + BitLength.numEntries;
+  for (let vendorId = 1; vendorId <= maxId; vendorId++) {
+    const vendorIsOn = vendorSet.has(vendorId);
+
+    // build our bitfield no matter what
+    bitField += _BooleanEncoder.default.encode(vendorIsOn);
+
+    // For each vendor ID up to maxId, we're re-evaluating whether the range
+    // grows larger than the bitfield. If it does, we'll abandon building
+    // the range
+    rangeIsSmaller = rangeIsSmaller && rangeLength < bitFieldLength;
+    if (rangeIsSmaller && vendorIsOn) {
+      const isEndOfRange = !vendorSet.has(vendorId + 1);
+      if (isEndOfRange) {
+        range.push(vendorId);
+
+        // add to the range length the additional vendorId
+        rangeLength += BitLength.vendorId;
+
+        // store the array in our bigger array
+        ranges.push(range);
+
+        // clear the array for the next range
+        range = [];
+      } else if (range.length === 0) {
+        // this is the first  value for this range
+        range.push(vendorId);
+
+        // update our count with new range overhead
+        rangeLength += BitLength.singleOrRange;
+        rangeLength += BitLength.vendorId;
+      }
+    }
+  }
+  rangeIsSmaller = rangeIsSmaller && rangeLength < bitFieldLength;
+
+  // since both encodings need the maxId, start with that
+  const encodedMaxId = _FixedIntegerEncoder.default.encode(maxId, BitLength.maxId);
+  return encodedMaxId + (rangeIsSmaller ? ENCODING_TYPE.RANGE.toString() + buildRangeEncoding(ranges) : ENCODING_TYPE.FIELD.toString() + bitField);
+};
+const decode = bitString => {
+  if (!bitString) {
+    return {
+      bitLength: 0,
+      value: {}
+    };
+  }
+  let index = 0;
+  const maxId = _FixedIntegerEncoder.default.decode(bitString.substr(index, BitLength.maxId), BitLength.maxId);
+  index += BitLength.maxId;
+  const encodingType = _FixedIntegerEncoder.default.decode(bitString.charAt(index), BitLength.encodingType);
+  index += BitLength.encodingType;
+
+  /**
+   * Range is handled in batches so we'll need a different decoding scheme
+   */
+  if (encodingType === ENCODING_TYPE.RANGE) {
+    const vendorIds = new Set();
+    const numEntries = _FixedIntegerEncoder.default.decode(bitString.substr(index, BitLength.numEntries), BitLength.numEntries);
+    index += BitLength.numEntries;
+
+    // loop through each group of entries
+    for (let i = 0; i < numEntries; i++) {
+      // Ranges can represent a single id or a range of ids.
+      const isIdRange = _BooleanEncoder.default.decode(bitString.charAt(index));
+      index += BitLength.singleOrRange;
+
+      /**
+       * regardless of whether or not it's a single entry or range, the next
+       * set of bits is a vendor ID
+       */
+      const firstId = _FixedIntegerEncoder.default.decode(bitString.substr(index, BitLength.vendorId), BitLength.vendorId);
+      index += BitLength.vendorId;
+
+      // if it's a range, the next set of bits is the second id
+      if (isIdRange) {
+        const secondId = _FixedIntegerEncoder.default.decode(bitString.substr(index, BitLength.vendorId), BitLength.vendorId);
+        index += BitLength.vendorId;
+
+        // we'll need to set or unset all the vendor ids between the first and second
+        for (let j = firstId; j <= secondId; j++) {
+          vendorIds.add(j);
+        }
+      } else {
+        vendorIds.add(firstId);
+      }
+    }
+    const decodedValue = {};
+    for (let vendorId = 1; vendorId <= maxId; vendorId++) {
+      decodedValue[vendorId] = vendorIds.has(vendorId);
+    }
+    return {
+      bitLength: index,
+      value: decodedValue
+    };
+  }
+
+  // Bitfield decoding
+  const bitField = bitString.substr(index, maxId);
+  index += maxId;
+  return {
+    bitLength: index,
+    value: _FixedIdBitMapEncoder.default.decode(bitField, maxId)
+  };
+};
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=EncodableOptimizedFixedRange.js.map

package/lib/commonjs/iab/gpp/encoders/EncodableOptimizedFixedRange.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_BooleanEncoder","_interopRequireDefault","require","_FixedIdBitMapEncoder","_FixedIntegerEncoder","obj","__esModule","default","BitLength","exports","encodingType","maxId","numEntries","singleOrRange","vendorId","HEADER_LENGTH","RANGE_MINIMUM_LENGTH","ENCODING_TYPE","FIELD","RANGE","buildRangeEncoding","ranges","length","rangeString","IntEncoder","encode","forEach","range","single","BooleanEncoder","value","vendorIds","Object","entries","filter","v","map","id","parsedId","parseInt","isNaN","test","Error","vendorSet","Set","Math","max","bitField","rangeIsSmaller","bitFieldLength","rangeLength","vendorIsOn","has","isEndOfRange","push","encodedMaxId","toString","decode","bitString","bitLength","index","substr","charAt","i","isIdRange","firstId","secondId","j","add","decodedValue","FixedIdBitMapEncoder","_default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/EncodableOptimizedFixedRange.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/FibonacciIntegerEncoder.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encode = exports.default = exports.decode = void 0;
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FibonacciIntegerEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+const encode = value => {
+  const fib = [];
+  if (value >= 1) {
+    fib.push(1);
+    if (value >= 2) {
+      fib.push(2);
+      let i = 2;
+      while (value >= fib[i - 1] + fib[i - 2]) {
+        fib.push(fib[i - 1] + fib[i - 2]);
+        i++;
+      }
+    }
+  }
+  let bitString = '1';
+  for (let i = fib.length - 1; i >= 0; i--) {
+    const f = fib[i];
+    if (value >= f) {
+      bitString = '1' + bitString;
+      value -= f;
+    } else {
+      bitString = '0' + bitString;
+    }
+  }
+  return bitString;
+};
+exports.encode = encode;
+const decode = bitString => {
+  if (!/^[01]*11$/.test(bitString)) {
+    throw new Error('Invalid bit string');
+  }
+  let value = 0;
+  const fib = [];
+  for (let i = 0; i < bitString.length - 1; i++) {
+    if (i === 0) {
+      fib.push(1);
+    } else if (i === 1) {
+      fib.push(2);
+    } else {
+      fib.push(fib[i - 1] + fib[i - 2]);
+    }
+  }
+  for (let i = 0; i < bitString.length - 1; i++) {
+    if (bitString.charAt(i) === '1') {
+      value += fib[i];
+    }
+  }
+  return value;
+};
+exports.decode = decode;
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=FibonacciIntegerEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/FibonacciIntegerEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["encode","value","fib","push","i","bitString","length","f","exports","decode","test","Error","charAt","_default","default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/FibonacciIntegerEncoder.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,MAAMA,MAAM,GAAIC,KAAa,IAAK;EACxC,MAAMC,GAAG,GAAG,EAAE;EACd,IAAID,KAAK,IAAI,CAAC,EAAE;IACfC,GAAG,CAACC,IAAI,CAAC,CAAC,CAAC;IAEX,IAAIF,KAAK,IAAI,CAAC,EAAE;MACfC,GAAG,CAACC,IAAI,CAAC,CAAC,CAAC;MAEX,IAAIC,CAAC,GAAG,CAAC;MACT,OAAOH,KAAK,IAAIC,GAAG,CAACE,CAAC,GAAG,CAAC,CAAC,GAAIF,GAAG,CAACE,CAAC,GAAG,CAAC,CAAE,EAAE;QAC1CF,GAAG,CAACC,IAAI,CAACD,GAAG,CAACE,CAAC,GAAG,CAAC,CAAC,GAAIF,GAAG,CAACE,CAAC,GAAG,CAAC,CAAE,CAAC;QACnCA,CAAC,EAAE;MACJ;IACD;EACD;EAEA,IAAIC,SAAS,GAAG,GAAG;EACnB,KAAK,IAAID,CAAC,GAAGF,GAAG,CAACI,MAAM,GAAG,CAAC,EAAEF,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;IACzC,MAAMG,CAAC,GAAGL,GAAG,CAACE,CAAC,CAAE;IACjB,IAAIH,KAAK,IAAIM,CAAC,EAAE;MACfF,SAAS,GAAG,GAAG,GAAGA,SAAS;MAC3BJ,KAAK,IAAIM,CAAC;IACX,CAAC,MAAM;MACNF,SAAS,GAAG,GAAG,GAAGA,SAAS;IAC5B;EACD;EAEA,OAAOA,SAAS;AACjB,CAAC;AAACG,OAAA,CAAAR,MAAA,GAAAA,MAAA;AAEK,MAAMS,MAAM,GAAIJ,SAAiB,IAAK;EAC5C,IAAI,CAAC,WAAW,CAACK,IAAI,CAACL,SAAS,CAAC,EAAE;IACjC,MAAM,IAAIM,KAAK,CAAC,oBAAoB,CAAC;EACtC;EAEA,IAAIV,KAAK,GAAG,CAAC;EAEb,MAAMC,GAAa,GAAG,EAAE;EACxB,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,GAAG,CAAC,EAAEF,CAAC,EAAE,EAAE;IAC9C,IAAIA,CAAC,KAAK,CAAC,EAAE;MACZF,GAAG,CAACC,IAAI,CAAC,CAAC,CAAC;IACZ,CAAC,MAAM,IAAIC,CAAC,KAAK,CAAC,EAAE;MACnBF,GAAG,CAACC,IAAI,CAAC,CAAC,CAAC;IACZ,CAAC,MAAM;MACND,GAAG,CAACC,IAAI,CAACD,GAAG,CAACE,CAAC,GAAG,CAAC,CAAC,GAAIF,GAAG,CAACE,CAAC,GAAG,CAAC,CAAE,CAAC;IACpC;EACD;EAEA,KAAK,IAAIA,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,GAAG,CAAC,EAAEF,CAAC,EAAE,EAAE;IAC9C,IAAIC,SAAS,CAACO,MAAM,CAACR,CAAC,CAAC,KAAK,GAAG,EAAE;MAChCH,KAAK,IAAIC,GAAG,CAACE,CAAC,CAAE;IACjB;EACD;EACA,OAAOH,KAAK;AACb,CAAC;AAACO,OAAA,CAAAC,MAAA,GAAAA,MAAA;AAAA,IAAAI,QAAA,GAAAL,OAAA,CAAAM,OAAA,GAEa;EACdL,MAAM;EACNT;AACD,CAAC","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/FibonacciIntegerRangeEncoder.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encode = exports.default = exports.decode = void 0;
+var _FibonacciIntegerEncoder = require("./FibonacciIntegerEncoder");
+var _FixedIntegerEncoder = require("./FixedIntegerEncoder");
+var _BooleanEncoder = require("./BooleanEncoder");
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FibonacciIntegerRangeEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+const encode = value => {
+  value = value.sort((n1, n2) => n1 - n2);
+  const groups = [];
+  let offset = 0;
+  let groupStartIndex = 0;
+  while (groupStartIndex < value.length) {
+    let groupEndIndex = groupStartIndex;
+    while (groupEndIndex < value.length - 1 && value[groupEndIndex] + 1 === value[groupEndIndex + 1]) {
+      groupEndIndex++;
+    }
+    groups.push(value.slice(groupStartIndex, groupEndIndex + 1));
+    groupStartIndex = groupEndIndex + 1;
+  }
+  let bitString = (0, _FixedIntegerEncoder.encode)(groups.length, 12);
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    if (group.length > 0) {
+      const startInt = group[0];
+      if (groups.length === 1) {
+        const v = startInt - offset;
+        offset = startInt;
+        bitString += '0' + (0, _FibonacciIntegerEncoder.encode)(v);
+      } else {
+        const startVal = startInt - offset;
+        offset = startInt;
+        const endInt = group[group.length - 1];
+        const endVal = endInt - offset;
+        offset = endInt;
+        bitString += '1' + (0, _FibonacciIntegerEncoder.encode)(startVal) + (0, _FibonacciIntegerEncoder.encode)(endVal);
+      }
+    }
+  }
+  return bitString;
+};
+exports.encode = encode;
+const decode = bitString => {
+  if (!/^[01]{12,}$/.test(bitString)) {
+    throw new Error('invalid bit string');
+  }
+  const value = [];
+  const count = (0, _FixedIntegerEncoder.decode)(bitString.substring(0, 12));
+  let offset = 0;
+  let startIndex = 12;
+  for (let i = 0; i < count; i++) {
+    const group = (0, _BooleanEncoder.decode)(bitString.substring(startIndex, startIndex + 1));
+    startIndex++;
+    if (group === true) {
+      let index = bitString.indexOf('11', startIndex);
+      const start = (0, _FibonacciIntegerEncoder.decode)(bitString.substring(startIndex, index + 2)) + offset;
+      offset = start;
+      startIndex = index + 2;
+      index = bitString.indexOf('11', startIndex);
+      const end = (0, _FibonacciIntegerEncoder.decode)(bitString.substring(startIndex, index + 2)) + offset;
+      offset = end;
+      startIndex = index + 2;
+      for (let j = start; j <= end; j++) {
+        value.push(j);
+      }
+    } else {
+      const index = bitString.indexOf('11', startIndex);
+      const val = (0, _FibonacciIntegerEncoder.decode)(bitString.substring(startIndex, index + 2)) + offset;
+      offset = val;
+      value.push(val);
+      startIndex = index + 2;
+    }
+  }
+  return value;
+};
+exports.decode = decode;
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=FibonacciIntegerRangeEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/FibonacciIntegerRangeEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FibonacciIntegerEncoder","require","_FixedIntegerEncoder","_BooleanEncoder","encode","value","sort","n1","n2","groups","offset","groupStartIndex","length","groupEndIndex","push","slice","bitString","intEncode","i","group","startInt","v","fibIntEncode","startVal","endInt","endVal","exports","decode","test","Error","count","intDecode","substring","startIndex","boolDecode","index","indexOf","start","fibIntDecode","end","j","val","_default","default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/FibonacciIntegerRangeEncoder.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/FixedBitfieldEncoder.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encode = exports.default = exports.decode = void 0;
+var _BooleanEncoder = require("./BooleanEncoder");
+var _errors = require("./errors");
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FixedBitfieldEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+const encode = (value, bitStringLength) => {
+  let bitString = '';
+  for (let i = 0; i < value.length; i++) {
+    bitString += (0, _BooleanEncoder.encode)(value[i]);
+  }
+
+  // String.prototype.padEnd causes CoreJS to include a polyfill for it.
+  bitString = bitString.length >= bitStringLength ? bitString : bitString + '0'.repeat(bitStringLength - bitString.length);
+  return bitString;
+};
+exports.encode = encode;
+const decode = (bitString, numBits = bitString.length) => {
+  if (!/^[01]*$/.test(bitString)) {
+    throw new _errors.InvalidBitStringError(bitString);
+  }
+  const value = [];
+  for (let i = 0; i < numBits; i++) {
+    value.push((0, _BooleanEncoder.decode)(bitString.substring(i, i + 1)));
+  }
+  return value;
+};
+exports.decode = decode;
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=FixedBitfieldEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/FixedBitfieldEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_BooleanEncoder","require","_errors","encode","value","bitStringLength","bitString","i","length","boolEncode","repeat","exports","decode","numBits","test","InvalidBitStringError","push","boolDecode","substring","_default","default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/FixedBitfieldEncoder.ts"],"mappings":";;;;;;AAqBA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,MAAME,MAAM,GAAGA,CAACC,KAAgB,EAAEC,eAAuB,KAAK;EACpE,IAAIC,SAAS,GAAG,EAAE;EAClB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,KAAK,CAACI,MAAM,EAAED,CAAC,EAAE,EAAE;IACtCD,SAAS,IAAI,IAAAG,sBAAU,EAACL,KAAK,CAACG,CAAC,CAAE,CAAC;EACnC;;EAEA;EACAD,SAAS,GACRA,SAAS,CAACE,MAAM,IAAIH,eAAe,GAChCC,SAAS,GACTA,SAAS,GAAG,GAAG,CAACI,MAAM,CAACL,eAAe,GAAGC,SAAS,CAACE,MAAM,CAAC;EAE9D,OAAOF,SAAS;AACjB,CAAC;AAACK,OAAA,CAAAR,MAAA,GAAAA,MAAA;AAEK,MAAMS,MAAM,GAAGA,CACrBN,SAAiB,EACjBO,OAAe,GAAGP,SAAS,CAACE,MAAM,KAC9B;EACJ,IAAI,CAAC,SAAS,CAACM,IAAI,CAACR,SAAS,CAAC,EAAE;IAC/B,MAAM,IAAIS,6BAAqB,CAACT,SAAS,CAAC;EAC3C;EAEA,MAAMF,KAAK,GAAG,EAAE;EAChB,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGM,OAAO,EAAEN,CAAC,EAAE,EAAE;IACjCH,KAAK,CAACY,IAAI,CAAC,IAAAC,sBAAU,EAACX,SAAS,CAACY,SAAS,CAACX,CAAC,EAAEA,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;EACtD;EACA,OAAOH,KAAK;AACb,CAAC;AAACO,OAAA,CAAAC,MAAA,GAAAA,MAAA;AAAA,IAAAO,QAAA,GAAAR,OAAA,CAAAS,OAAA,GAEa;EACdR,MAAM;EACNT;AACD,CAAC","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/FixedIdBitMapEncoder.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _FixedBitfieldEncoder = _interopRequireDefault(require("./FixedBitfieldEncoder"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This encoder is used to encode and decode ID-to-bit/boolean maps to and from
+// fixed bitfields.It doesn't exactly have an equivalent in the GPP reference
+// implementation but the EncodableFixedBitfield class is similar.
+// https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/EncodableFixedBitfield.ts.
+// The functional difference is that it encodes from and decodes to an array of
+// booleans whereas this encoder encodes from and decodes to an object of
+// ID-to-boolean mappings.
+var _default = exports.default = {
+  encode: (value, numBits) => _FixedBitfieldEncoder.default.encode(Object.entries(value || {}).reduce((acc, [key, bit]) => {
+    const id = parseInt(key, 10);
+    acc[id - 1] = bit;
+    return acc;
+  }, []), numBits),
+  decode: (bitString, numBits) => _FixedBitfieldEncoder.default.decode(bitString, numBits).reduce((acc, value, index) => {
+    acc[index + 1] = value;
+    return acc;
+  }, {})
+};
+//# sourceMappingURL=FixedIdBitMapEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/FixedIdBitMapEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FixedBitfieldEncoder","_interopRequireDefault","require","obj","__esModule","default","_default","exports","encode","value","numBits","FixedBitfieldEncoder","Object","entries","reduce","acc","key","bit","id","parseInt","decode","bitString","index"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/FixedIdBitMapEncoder.ts"],"mappings":";;;;;;AAQA,IAAAA,qBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA0D,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAR1D;AACA;AACA;AACA;AACA;AACA;AACA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAIe;EACdG,MAAM,EAAEA,CAACC,KAA8B,EAAEC,OAAe,KACvDC,6BAAoB,CAACH,MAAM,CAC1BI,MAAM,CAACC,OAAO,CAACJ,KAAK,IAAI,CAAC,CAAC,CAAC,CAACK,MAAM,CAAC,CAACC,GAAG,EAAE,CAACC,GAAG,EAAEC,GAAG,CAAC,KAAK;IACvD,MAAMC,EAAE,GAAGC,QAAQ,CAACH,GAAG,EAAE,EAAE,CAAC;IAC5BD,GAAG,CAACG,EAAE,GAAG,CAAC,CAAC,GAAGD,GAAG;IACjB,OAAOF,GAAG;EACX,CAAC,EAAE,EAAe,CAAC,EACnBL,OACD,CAAC;EAEFU,MAAM,EAAEA,CAACC,SAAiB,EAAEX,OAAe,KAC1CC,6BAAoB,CAACS,MAAM,CAACC,SAAS,EAAEX,OAAO,CAAC,CAACI,MAAM,CACrD,CAACC,GAAG,EAAEN,KAAK,EAAEa,KAAK,KAAK;IACtBP,GAAG,CAACO,KAAK,GAAG,CAAC,CAAC,GAAGb,KAAK;IACtB,OAAOM,GAAG;EACX,CAAC,EACD,CAAC,CACF;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/iab/gpp/encoders/FixedIntegerEncoder.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encode = exports.default = exports.decode = void 0;
+var _errors = require("./errors.js");
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FixedIntegerEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+// We use browser native functions to encode/decode integers to/from bit strings
+// instead of the more verbose method in the reference implementation
+
+const encode = (int, numBits) => {
+  let bitString;
+  if (typeof int === 'string') {
+    int = parseInt(int, 10);
+  }
+  bitString = int.toString(2);
+  if (bitString.length > numBits || int < 0) {
+    throw new _errors.InvalidSizeError(int, numBits);
+  }
+
+  // Pad the string if not filling all bits
+  if (bitString.length < numBits) {
+    // pad left
+    bitString = '0'.repeat(numBits - bitString.length) + bitString;
+  }
+  return bitString;
+};
+exports.encode = encode;
+const decode = (bitString, numBits) => {
+  if (!bitString) {
+    // Handle falsy values
+    return 0;
+  }
+  return parseInt(bitString.slice(0, numBits), 2);
+};
+exports.decode = decode;
+var _default = exports.default = {
+  decode,
+  encode
+};
+//# sourceMappingURL=FixedIntegerEncoder.js.map

package/lib/commonjs/iab/gpp/encoders/FixedIntegerEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","encode","int","numBits","bitString","parseInt","toString","length","InvalidSizeError","repeat","exports","decode","slice","_default","default"],"sourceRoot":"../../../../../src","sources":["iab/gpp/encoders/FixedIntegerEncoder.ts"],"mappings":";;;;;;AAqBA,IAAAA,OAAA,GAAAC,OAAA;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;;AAEO,MAAMC,MAAM,GAAGA,CAACC,GAAoB,EAAEC,OAAe,KAAK;EAChE,IAAIC,SAAS;EAEb,IAAI,OAAOF,GAAG,KAAK,QAAQ,EAAE;IAC5BA,GAAG,GAAGG,QAAQ,CAACH,GAAG,EAAE,EAAE,CAAC;EACxB;EAEAE,SAAS,GAAGF,GAAG,CAACI,QAAQ,CAAC,CAAC,CAAC;EAE3B,IAAIF,SAAS,CAACG,MAAM,GAAGJ,OAAO,IAAID,GAAG,GAAG,CAAC,EAAE;IAC1C,MAAM,IAAIM,wBAAgB,CAACN,GAAG,EAAEC,OAAO,CAAC;EACzC;;EAEA;EACA,IAAIC,SAAS,CAACG,MAAM,GAAGJ,OAAO,EAAE;IAC/B;IACAC,SAAS,GAAG,GAAG,CAACK,MAAM,CAACN,OAAO,GAAGC,SAAS,CAACG,MAAM,CAAC,GAAGH,SAAS;EAC/D;EAEA,OAAOA,SAAS;AACjB,CAAC;AAACM,OAAA,CAAAT,MAAA,GAAAA,MAAA;AAEK,MAAMU,MAAM,GAAGA,CAACP,SAAiB,EAAED,OAAgB,KAAK;EAC9D,IAAI,CAACC,SAAS,EAAE;IACf;IACA,OAAO,CAAC;EACT;EAEA,OAAOC,QAAQ,CAACD,SAAS,CAACQ,KAAK,CAAC,CAAC,EAAET,OAAO,CAAC,EAAE,CAAC,CAAC;AAChD,CAAC;AAACO,OAAA,CAAAC,MAAA,GAAAA,MAAA;AAAA,IAAAE,QAAA,GAAAH,OAAA,CAAAI,OAAA,GAEa;EACdH,MAAM;EACNV;AACD,CAAC","ignoreList":[]}