@pubtech-ai/core 1.6.0

package/lib/mjs/encoder/Base64Url.js

@@ -0,0 +1,80 @@
+import { DecodingError, EncodingError } from '../errors/index.js';
+export class Base64Url {
+    /**
+     * Base 64 URL character set.  Different from standard Base64 char set
+     * in that '+' and '/' are replaced with '-' and '_'.
+     */
+    static DICT = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+    static REVERSE_DICT = 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
+     */
+    static BASIS = 6;
+    static LCM = 24;
+    /**
+     * encodes an arbitrary-length bitfield string into base64url
+     *
+     * @static
+     * @param {string} str - arbitrary-length bitfield string to be encoded to base64url
+     * @return {string} - base64url encoded result
+     */
+    static encode(str) {
+        /**
+         * should only be 0 or 1
+         */
+        if (!/^[0-1]+$/.test(str)) {
+            throw new EncodingError('Invalid bitField');
+        }
+        /**
+         * Pad the end of the string to the least common mutliple of 6 (basis for
+         * base64) and 8 (one byte)
+         */
+        const padding = str.length % this.LCM;
+        str += padding ? '0'.repeat(this.LCM - padding) : '';
+        let result = '';
+        for (let i = 0; i < str.length; i += this.BASIS) {
+            result += this.DICT[parseInt(str.substr(i, this.BASIS), 2)];
+        }
+        return result;
+    }
+    /**
+     * decodes a base64url encoded bitfield string
+     *
+     * @static
+     * @param {string} str - base64url encoded bitfield string to be decoded
+     * @return {string} - bitfield string
+     */
+    static decode(str) {
+        /**
+         * should contain only characters from the base64url set
+         */
+        if (!/^[A-Za-z0-9\-_]+$/.test(str)) {
+            throw new DecodingError('Invalidly encoded Base64URL string');
+        }
+        let result = '';
+        for (let i = 0; i < str.length; i++) {
+            /**
+             * index the binary value of the character from out reverse map
+             */
+            const strBits = this.REVERSE_DICT.get(str[i]).toString(2);
+            /**
+             * Since a bit string converted to an integer on encoding will lose
+             * leading zeros – pad to the left for those missing leading zeros
+             */
+            result += '0'.repeat(this.BASIS - strBits.length) + strBits;
+        }
+        return result;
+    }
+}

package/lib/mjs/encoder/BitLength.d.ts

@@ -0,0 +1,32 @@
+import { Fields } from '../model/index.js';
+export declare class BitLength {
+    static readonly [Fields.cmpId]: number;
+    static readonly [Fields.cmpVersion]: number;
+    static readonly [Fields.consentLanguage]: number;
+    static readonly [Fields.consentScreen]: number;
+    static readonly [Fields.created]: number;
+    static readonly [Fields.isServiceSpecific]: number;
+    static readonly [Fields.lastUpdated]: number;
+    static readonly [Fields.policyVersion]: number;
+    static readonly [Fields.publisherCountryCode]: number;
+    static readonly [Fields.publisherLegitimateInterests]: number;
+    static readonly [Fields.publisherConsents]: number;
+    static readonly [Fields.purposeConsents]: number;
+    static readonly [Fields.purposeLegitimateInterests]: number;
+    static readonly [Fields.purposeOneTreatment]: number;
+    static readonly [Fields.specialFeatureOptins]: number;
+    static readonly [Fields.useNonStandardStacks]: number;
+    static readonly [Fields.vendorListVersion]: number;
+    static readonly [Fields.version]: number;
+    static readonly anyBoolean: number;
+    static readonly encodingType: number;
+    static readonly maxId: number;
+    static readonly numCustomPurposes: number;
+    static readonly numEntries: number;
+    static readonly numRestrictions: number;
+    static readonly purposeId: number;
+    static readonly restrictionType: number;
+    static readonly segmentType: number;
+    static readonly singleOrRange: number;
+    static readonly vendorId: number;
+}

package/lib/mjs/encoder/BitLength.js

@@ -0,0 +1,32 @@
+import { Fields } from '../model/index.js';
+export class BitLength {
+    static [Fields.cmpId] = 12;
+    static [Fields.cmpVersion] = 12;
+    static [Fields.consentLanguage] = 12;
+    static [Fields.consentScreen] = 6;
+    static [Fields.created] = 36;
+    static [Fields.isServiceSpecific] = 1;
+    static [Fields.lastUpdated] = 36;
+    static [Fields.policyVersion] = 6;
+    static [Fields.publisherCountryCode] = 12;
+    static [Fields.publisherLegitimateInterests] = 24;
+    static [Fields.publisherConsents] = 24;
+    static [Fields.purposeConsents] = 24;
+    static [Fields.purposeLegitimateInterests] = 24;
+    static [Fields.purposeOneTreatment] = 1;
+    static [Fields.specialFeatureOptins] = 12;
+    static [Fields.useNonStandardStacks] = 1;
+    static [Fields.vendorListVersion] = 12;
+    static [Fields.version] = 6;
+    static anyBoolean = 1;
+    static encodingType = 1;
+    static maxId = 16;
+    static numCustomPurposes = 6;
+    static numEntries = 12;
+    static numRestrictions = 12;
+    static purposeId = 6;
+    static restrictionType = 2;
+    static segmentType = 3;
+    static singleOrRange = 1;
+    static vendorId = 16;
+}

package/lib/mjs/encoder/EncodingOptions.d.ts

@@ -0,0 +1,6 @@
+import { Segment } from '../model/index.js';
+export interface EncodingOptions {
+    isForVendors?: boolean;
+    version?: 1 | 2;
+    segments?: Segment[];
+}

package/lib/mjs/encoder/EncodingOptions.js

@@ -0,0 +1 @@
+export {};

package/lib/mjs/encoder/SegmentEncoder.d.ts

@@ -0,0 +1,8 @@
+import { Segment } from '../model/index.js';
+import { TCModel } from '../index.js';
+export declare class SegmentEncoder {
+    private static fieldSequence;
+    static encode(tcModel: TCModel, segment: Segment): string;
+    static decode(encodedString: string, tcModel: TCModel, segment: string): TCModel;
+    private static isPublisherCustom;
+}

package/lib/mjs/encoder/SegmentEncoder.js

@@ -0,0 +1,106 @@
+import { Base64Url } from './Base64Url.js';
+import { BitLength } from './BitLength.js';
+import { FieldEncoderMap, IntEncoder, VendorVectorEncoder } from './field/index.js';
+import { FieldSequence } from './sequence/index.js';
+import { EncodingError, DecodingError } from '../errors/index.js';
+import { Fields } from '../model/Fields.js';
+import { Segment, SegmentIDs } from '../model/index.js';
+export class SegmentEncoder {
+    static fieldSequence = new FieldSequence();
+    static encode(tcModel, segment) {
+        let sequence;
+        try {
+            sequence = this.fieldSequence[String(tcModel.version)][segment];
+        }
+        catch (err) {
+            throw new EncodingError(`Unable to encode version: ${tcModel.version}, segment: ${segment}`);
+        }
+        let bitField = '';
+        /**
+         * If this is anything other than the core segment we have a "segment id"
+         * to append to the front of the string
+         */
+        if (segment !== Segment.CORE) {
+            bitField = IntEncoder.encode(SegmentIDs.KEY_TO_ID[segment], BitLength.segmentType);
+        }
+        const fieldEncoderMap = FieldEncoderMap();
+        sequence.forEach((key) => {
+            const value = tcModel[key];
+            const encoder = fieldEncoderMap[key];
+            let numBits = BitLength[key];
+            if (numBits === undefined) {
+                if (this.isPublisherCustom(key)) {
+                    /**
+                     * publisherCustom[Consents | LegitimateInterests] are an edge case
+                     * because they are of variable length. The length is defined in a
+                     * separate field named numCustomPurposes.
+                     */
+                    numBits = Number(tcModel[Fields.numCustomPurposes]);
+                }
+            }
+            try {
+                bitField += encoder.encode(value, numBits);
+            }
+            catch (err) {
+                throw new EncodingError(`Error encoding ${segment}->${key}: ${err.message}`);
+            }
+        });
+        // base64url encode the string and return
+        return Base64Url.encode(bitField);
+    }
+    static decode(encodedString, tcModel, segment) {
+        const bitField = Base64Url.decode(encodedString);
+        let bStringIdx = 0;
+        if (segment === Segment.CORE) {
+            tcModel.version = IntEncoder.decode(bitField.substr(bStringIdx, BitLength[Fields.version]), BitLength[Fields.version]);
+        }
+        if (segment !== Segment.CORE) {
+            bStringIdx += BitLength.segmentType;
+        }
+        const sequence = this.fieldSequence[String(tcModel.version)][segment];
+        const fieldEncoderMap = FieldEncoderMap();
+        sequence.forEach((key) => {
+            const encoder = fieldEncoderMap[key];
+            let numBits = BitLength[key];
+            if (numBits === undefined) {
+                if (this.isPublisherCustom(key)) {
+                    /**
+                     * publisherCustom[Consents | LegitimateInterests] are an edge case
+                     * because they are of variable length. The length is defined in a
+                     * separate field named numCustomPurposes.
+                     */
+                    numBits = Number(tcModel[Fields.numCustomPurposes]);
+                }
+            }
+            if (numBits !== 0) {
+                /**
+                 * numBits could be 0 if this is a publisher custom purposes field and
+                 * no custom purposes are defined. If that is the case, we don't need
+                 * to gather no bits and we don't need to increment our bStringIdx
+                 * pointer because those would all be 0 increments and would mess up
+                 * the next logical if statement.
+                 */
+                const bits = bitField.substr(bStringIdx, numBits);
+                if (encoder === VendorVectorEncoder) {
+                    tcModel[key] = encoder.decode(bits, tcModel.version);
+                }
+                else {
+                    tcModel[key] = encoder.decode(bits, numBits);
+                }
+                if (Number.isInteger(numBits)) {
+                    bStringIdx += numBits;
+                }
+                else if (Number.isInteger(tcModel[key].bitLength)) {
+                    bStringIdx += tcModel[key].bitLength;
+                }
+                else {
+                    throw new DecodingError(key);
+                }
+            }
+        });
+        return tcModel;
+    }
+    static isPublisherCustom(key) {
+        return key.indexOf('publisherCustom') === 0;
+    }
+}

package/lib/mjs/encoder/SemanticPreEncoder.d.ts

@@ -0,0 +1,6 @@
+import { TCModel } from '../TCModel.js';
+import { EncodingOptions } from './EncodingOptions.js';
+export declare class SemanticPreEncoder {
+    private static processor;
+    static process(tcModel: TCModel, options?: EncodingOptions): TCModel;
+}

package/lib/mjs/encoder/SemanticPreEncoder.js

@@ -0,0 +1,133 @@
+import { EncodingError } from '../errors/index.js';
+import { RestrictionType } from '../model/index.js';
+export class SemanticPreEncoder {
+    static processor = [
+        (tcModel) => tcModel,
+        (tcModel, gvl) => {
+            /**
+             * in case this wasn't set previously.  This should filter out invalid
+             * purpose restrictions.
+             */
+            tcModel.publisherRestrictions.gvl = gvl;
+            /**
+             * Purpose 1 is never allowed to be true for legitimate interest
+             * As of TCF v2.2 purposes 3,4,5 & 6 are not allowed to be true for LI
+             */
+            tcModel.purposeLegitimateInterests.unset([1, 3, 4, 5, 6]);
+            /**
+             * If a Vendor does not declare a purpose for consent or legitimate
+             * interest they should not have a positive signal for it. This code
+             * removes positive signals created mistakingly.
+             */
+            const vectorToIntMap = new Map();
+            vectorToIntMap.set('legIntPurposes', tcModel.vendorLegitimateInterests);
+            vectorToIntMap.set('purposes', tcModel.vendorConsents);
+            vectorToIntMap.forEach((vector, gvlVendorKey) => {
+                vector.forEach((value, vendorId) => {
+                    if (value) {
+                        const vendor = gvl.vendors[vendorId];
+                        if (!vendor || vendor.deletedDate) {
+                            /**
+                             * If the vendor doesn't exist, then they should not receive a
+                             * positive signal
+                             */
+                            vector.unset(vendorId);
+                        }
+                        else if (vendor[gvlVendorKey].length === 0) {
+                            if (gvlVendorKey === 'legIntPurposes' && vendor['purposes'].length === 0 && vendor['legIntPurposes'].length === 0 && vendor['specialPurposes'].length > 0) {
+                                /**
+                                 * Per June 2021 Policy change, Vendors declaring only Special Purposes must
+                                 * have their legitimate interest Vendor bit set if they have been disclosed.
+                                 * This empty block ensures their LI bit remains set
+                                 */
+                            }
+                            else {
+                                /**
+                                 * If the vendor does exist, but they haven't declared any
+                                 * purposes for this legal basis, then we need to see if they can
+                                 * possibly have the legal basis from their flexible purposes.
+                                 */
+                                if (tcModel.isServiceSpecific) {
+                                    if (vendor.flexiblePurposes.length === 0) {
+                                        /**
+                                         * No flexible basis for any purposes, so we can safely remove
+                                         * this vendor from the legal basis.
+                                         */
+                                        vector.unset(vendorId);
+                                    }
+                                    else {
+                                        /**
+                                         * They have some flexible purposes, we should check for a
+                                         * publisher restriction value that would enable this vendor to
+                                         * have the override-preferred basis.
+                                         */
+                                        const restrictions = tcModel.publisherRestrictions.getRestrictions(vendorId);
+                                        let isValid = false;
+                                        for (let i = 0, len = restrictions.length; i < len && !isValid; i++) {
+                                            /**
+                                             * If this condition is true the loop will break.  If we are
+                                             * dealing with the consent purposes ('purposes') and the
+                                             * publisher restriction overrides to consent then it is
+                                             * valid for the vendor to have a positive signal for
+                                             * consent.  Likewise for legitimate interest purposes
+                                             * ('legIntPurposes') and requiring legitimate interest.
+                                             */
+                                            isValid = ((restrictions[i].restrictionType === RestrictionType.REQUIRE_CONSENT &&
+                                                gvlVendorKey === 'purposes') ||
+                                                (restrictions[i].restrictionType === RestrictionType.REQUIRE_LI &&
+                                                    gvlVendorKey === 'legIntPurposes'));
+                                        }
+                                        if (!isValid) {
+                                            /**
+                                             * if we came through the previous  loop without finding a
+                                             * valid reasing: no overriding restrictions (changes in
+                                             * legal basis) then it's not valid for this vendor to have
+                                             * this legal basis.
+                                             */
+                                            vector.unset(vendorId);
+                                        }
+                                    }
+                                }
+                                else {
+                                    /**
+                                     * This is a globally-scoped string so flexible purposes will not
+                                     * be able to change this value because purposeRestrictions only
+                                     * apply to service-specific strings.
+                                     */
+                                    vector.unset(vendorId);
+                                }
+                            }
+                        }
+                    }
+                });
+            });
+            tcModel.vendorsDisclosed.set(gvl.vendors);
+            return tcModel;
+        },
+    ];
+    static process(tcModel, options) {
+        const gvl = tcModel.gvl;
+        if (!gvl) {
+            throw new EncodingError('Unable to encode TCModel without a GVL');
+        }
+        if (!gvl.isReady) {
+            throw new EncodingError('Unable to encode TCModel tcModel.gvl.readyPromise is not resolved');
+        }
+        tcModel = tcModel.clone();
+        tcModel.consentLanguage = gvl.language.toUpperCase();
+        if (options?.version > 0 && options?.version <= this.processor.length) {
+            tcModel.version = options.version;
+        }
+        else {
+            /**
+             * this is equal to the latest or most current version
+             */
+            tcModel.version = this.processor.length;
+        }
+        const processorFunctionIndex = tcModel.version - 1;
+        if (!this.processor[processorFunctionIndex]) {
+            throw new EncodingError(`Invalid version: ${tcModel.version}`);
+        }
+        return this.processor[processorFunctionIndex](tcModel, gvl);
+    }
+}

package/lib/mjs/encoder/field/BooleanEncoder.d.ts

@@ -0,0 +1,4 @@
+export declare class BooleanEncoder {
+    static encode(value: boolean): string;
+    static decode(value: string): boolean;
+}

package/lib/mjs/encoder/field/BooleanEncoder.js

@@ -0,0 +1,9 @@
+export class BooleanEncoder {
+    static encode(value) {
+        return String(Number(value));
+    }
+    static decode(value) {
+        // less operations than !!parseInt(value, 2)
+        return value === '1';
+    }
+}

package/lib/mjs/encoder/field/DateEncoder.d.ts

@@ -0,0 +1,4 @@
+export declare class DateEncoder {
+    static encode(value: Date, numBits: number): string;
+    static decode(value: string, numBits: number): Date;
+}

package/lib/mjs/encoder/field/DateEncoder.js

@@ -0,0 +1,15 @@
+import { IntEncoder, } from './IntEncoder.js';
+import { DecodingError, } from '../../errors/index.js';
+export class DateEncoder {
+    static encode(value, numBits) {
+        return IntEncoder.encode(Math.round(value.getTime() / 100), numBits);
+    }
+    static decode(value, numBits) {
+        if (numBits !== value.length) {
+            throw new DecodingError('invalid bit length');
+        }
+        const date = new Date();
+        date.setTime(IntEncoder.decode(value, numBits) * 100);
+        return date;
+    }
+}

package/lib/mjs/encoder/field/FieldEncoderMap.d.ts

@@ -0,0 +1 @@
+export declare function FieldEncoderMap(): object;

package/lib/mjs/encoder/field/FieldEncoderMap.js

@@ -0,0 +1,39 @@
+import { Fields } from '../../model/index.js';
+import { BooleanEncoder } from './BooleanEncoder.js';
+import { DateEncoder } from './DateEncoder.js';
+import { FixedVectorEncoder } from './FixedVectorEncoder.js';
+import { IntEncoder } from './IntEncoder.js';
+import { LangEncoder } from './LangEncoder.js';
+import { PurposeRestrictionVectorEncoder } from './PurposeRestrictionVectorEncoder.js';
+import { VendorVectorEncoder } from './VendorVectorEncoder.js';
+export function FieldEncoderMap() {
+    return {
+        [Fields.version]: IntEncoder,
+        [Fields.created]: DateEncoder,
+        [Fields.lastUpdated]: DateEncoder,
+        [Fields.cmpId]: IntEncoder,
+        [Fields.cmpVersion]: IntEncoder,
+        [Fields.consentScreen]: IntEncoder,
+        [Fields.consentLanguage]: LangEncoder,
+        [Fields.vendorListVersion]: IntEncoder,
+        [Fields.policyVersion]: IntEncoder,
+        [Fields.isServiceSpecific]: BooleanEncoder,
+        [Fields.useNonStandardStacks]: BooleanEncoder,
+        [Fields.specialFeatureOptins]: FixedVectorEncoder,
+        [Fields.purposeConsents]: FixedVectorEncoder,
+        [Fields.purposeLegitimateInterests]: FixedVectorEncoder,
+        [Fields.purposeOneTreatment]: BooleanEncoder,
+        [Fields.publisherCountryCode]: LangEncoder,
+        [Fields.vendorConsents]: VendorVectorEncoder,
+        [Fields.vendorLegitimateInterests]: VendorVectorEncoder,
+        [Fields.publisherRestrictions]: PurposeRestrictionVectorEncoder,
+        segmentType: IntEncoder,
+        [Fields.vendorsDisclosed]: VendorVectorEncoder,
+        [Fields.vendorsAllowed]: VendorVectorEncoder,
+        [Fields.publisherConsents]: FixedVectorEncoder,
+        [Fields.publisherLegitimateInterests]: FixedVectorEncoder,
+        [Fields.numCustomPurposes]: IntEncoder,
+        [Fields.publisherCustomConsents]: FixedVectorEncoder,
+        [Fields.publisherCustomLegitimateInterests]: FixedVectorEncoder,
+    };
+}

package/lib/mjs/encoder/field/FixedVectorEncoder.d.ts

@@ -0,0 +1,5 @@
+import { Vector } from '../../model/index.js';
+export declare class FixedVectorEncoder {
+    static encode(value: Vector, numBits: number): string;
+    static decode(value: string, numBits: number): Vector;
+}

package/lib/mjs/encoder/field/FixedVectorEncoder.js

@@ -0,0 +1,25 @@
+import { BooleanEncoder } from './BooleanEncoder.js';
+import { DecodingError } from '../../errors/index.js';
+import { Vector } from '../../model/index.js';
+export class FixedVectorEncoder {
+    static encode(value, numBits) {
+        let bitString = '';
+        for (let i = 1; i <= numBits; i++) {
+            bitString += BooleanEncoder.encode(value.has(i));
+        }
+        return bitString;
+    }
+    static decode(value, numBits) {
+        if (value.length !== numBits) {
+            throw new DecodingError('bitfield encoding length mismatch');
+        }
+        const vector = new Vector();
+        for (let i = 1; i <= numBits; i++) {
+            if (BooleanEncoder.decode(value[i - 1])) {
+                vector.set(i);
+            }
+        }
+        vector.bitLength = value.length;
+        return vector;
+    }
+}

package/lib/mjs/encoder/field/IntEncoder.d.ts

@@ -0,0 +1,4 @@
+export declare class IntEncoder {
+    static encode(value: number | string, numBits: number): string;
+    static decode(value: string, numBits: number): number;
+}

package/lib/mjs/encoder/field/IntEncoder.js

@@ -0,0 +1,25 @@
+import { EncodingError, DecodingError, } from '../../errors/index.js';
+export class IntEncoder {
+    static encode(value, numBits) {
+        let bitString;
+        if (typeof value === 'string') {
+            value = parseInt(value, 10);
+        }
+        bitString = value.toString(2);
+        if (bitString.length > numBits || value < 0) {
+            throw new EncodingError(`${value} too large to encode into ${numBits}`);
+        }
+        // Pad the string if not filling all bits
+        if (bitString.length < numBits) {
+            // pad left
+            bitString = '0'.repeat(numBits - bitString.length) + bitString;
+        }
+        return bitString;
+    }
+    static decode(value, numBits) {
+        if (numBits !== value.length) {
+            throw new DecodingError('invalid bit length');
+        }
+        return parseInt(value, 2);
+    }
+}

package/lib/mjs/encoder/field/LangEncoder.d.ts

@@ -0,0 +1,4 @@
+export declare class LangEncoder {
+    static encode(value: string, numBits: number): string;
+    static decode(value: string, numBits: number): string;
+}

package/lib/mjs/encoder/field/LangEncoder.js

@@ -0,0 +1,36 @@
+import { IntEncoder, } from './IntEncoder.js';
+import { DecodingError, EncodingError, } from '../../errors/index.js';
+export class LangEncoder {
+    static encode(value, numBits) {
+        value = value.toUpperCase();
+        const ASCII_START = 65;
+        const firstLetter = value.charCodeAt(0) - ASCII_START;
+        const secondLetter = value.charCodeAt(1) - ASCII_START;
+        // check some things to throw some good errors
+        if (firstLetter < 0 || firstLetter > 25 || secondLetter < 0 || secondLetter > 25) {
+            throw new EncodingError(`invalid language code: ${value}`);
+        }
+        if (numBits % 2 === 1) {
+            throw new EncodingError(`numBits must be even, ${numBits} is not valid`);
+        }
+        numBits = numBits / 2;
+        const firstLetterBString = IntEncoder.encode(firstLetter, numBits);
+        const secondLetterBString = IntEncoder.encode(secondLetter, numBits);
+        return firstLetterBString + secondLetterBString;
+    }
+    static decode(value, numBits) {
+        let retr;
+        // is it an even number of bits? we have to divide it
+        if (numBits === value.length && !(value.length % 2)) {
+            const ASCII_START = 65;
+            const mid = value.length / 2;
+            const firstLetter = IntEncoder.decode(value.slice(0, mid), mid) + ASCII_START;
+            const secondLetter = IntEncoder.decode(value.slice(mid), mid) + ASCII_START;
+            retr = String.fromCharCode(firstLetter) + String.fromCharCode(secondLetter);
+        }
+        else {
+            throw new DecodingError('invalid bit length for language');
+        }
+        return retr;
+    }
+}

package/lib/mjs/encoder/field/PurposeRestrictionVectorEncoder.d.ts

@@ -0,0 +1,5 @@
+import { PurposeRestrictionVector } from '../../model/index.js';
+export declare class PurposeRestrictionVectorEncoder {
+    static encode(prVector: PurposeRestrictionVector): string;
+    static decode(encodedString: string): PurposeRestrictionVector;
+}