@aidc-toolkit/gs1 1.0.31-beta → 1.0.33-beta

package/test/gtin-validator.ts

@@ -0,0 +1,30 @@
+import {
+    type GTINBaseLength,
+    GTINLengths,
+    type GTINValidator,
+    IdentifierTypes,
+    LeaderTypes,
+    type PrefixType,
+    PrefixTypes
+} from "../src/index.js";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
+
+export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinBaseLength: GTINBaseLength): void {
+    let prefixType: PrefixType;
+
+    switch (gtinBaseLength) {
+        case GTINLengths.GTIN13:
+            prefixType = PrefixTypes.GS1CompanyPrefix;
+            break;
+
+        case GTINLengths.GTIN12:
+            prefixType = PrefixTypes.UPCCompanyPrefix;
+            break;
+
+        case GTINLengths.GTIN8:
+            prefixType = PrefixTypes.GS18Prefix;
+            break;
+    }
+
+    validateNumericIdentifierValidator(validator, IdentifierTypes.GTIN, prefixType, gtinBaseLength, LeaderTypes.IndicatorDigit);
+}

package/test/identifier-creator.ts

@@ -8,9 +8,9 @@ import {
     type PrefixManager,
     PrefixTypes
 } from "../src/index.js";
-import { validateGTINValidator } from "./gtin-validator.test.js";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { validateGTINValidator } from "./gtin-validator.js";
 import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { validateNonSerializableNumericIdentifierValidator } from "./non-serializable-numeric-identifier-validator.js";
 import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 export function validateIdentifierCreators(prefixManager: PrefixManager): void {
@@ -52,14 +52,14 @@ export function validateIdentifierCreators(prefixManager: PrefixManager): void {
         expect(prefixManager.cpidCreator).toBe(prefixManager.cpidCreator);
         expect(prefixManager.gmnCreator).toBe(prefixManager.gmnCreator);
 
-        validateNonGTINNumericIdentifierValidator(prefixManager.glnCreator, true, IdentifierTypes.GLN, 13, LeaderTypes.None);
-        validateNonGTINNumericIdentifierValidator(prefixManager.ssccCreator, true, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
+        validateNonSerializableNumericIdentifierValidator(prefixManager.glnCreator, true, IdentifierTypes.GLN, 13, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(prefixManager.ssccCreator, true, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
         validateSerializableNumericIdentifierValidator(prefixManager.graiCreator, true, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
         validateNonNumericIdentifierValidator(prefixManager.giaiCreator, true, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(prefixManager.gsrnCreator, true, IdentifierTypes.GSRN, 18, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(prefixManager.gsrnCreator, true, IdentifierTypes.GSRN, 18, LeaderTypes.None);
         validateSerializableNumericIdentifierValidator(prefixManager.gdtiCreator, true, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
         validateNonNumericIdentifierValidator(prefixManager.gincCreator, true, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(prefixManager.gsinCreator, true, IdentifierTypes.GSIN, 17, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(prefixManager.gsinCreator, true, IdentifierTypes.GSIN, 17, LeaderTypes.None);
         validateSerializableNumericIdentifierValidator(prefixManager.gcnCreator, true, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
         validateNonNumericIdentifierValidator(prefixManager.cpidCreator, true, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
         validateNonNumericIdentifierValidator(prefixManager.gmnCreator, true, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);

package/test/non-numeric-identifier-creator.ts

@@ -68,14 +68,6 @@ export function testNonNumericIdentifierCreator(creator: NonNumericIdentifierCre
             expect(index).toBe(referenceCount);
         });
 
-        test("Position offset", () => {
-            expect(() => {
-                creator.validate(creator.create("ABC123"), {
-                    positionOffset: 4
-                });
-            }).not.toThrow(RangeError);
-        });
-
         test("Not all numeric", () => {
             expect(() => {
                 creator.validate(creator.create("01234"), {

package/test/non-serializable-numeric-identifier-creator.ts

@@ -1,64 +1,14 @@
 import { expect, test } from "vitest";
 import {
-    ContentCharacterSets,
-    isSerializableNumericIdentifierCreator,
-    type SerializableNumericIdentifierCreator
+    isNonSerializableNumericIdentifierCreator,
+    type NonSerializableNumericIdentifierCreator
 } from "../src/index.js";
 import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
 
-export function testSerializableNumericIdentifierCreator(creator: SerializableNumericIdentifierCreator): void {
+export function testNonSerializableNumericIdentifierCreator(creator: NonSerializableNumericIdentifierCreator): void {
     testNonGTINNumericIdentifierCreator(creator, () => {
         test("Mapping", () => {
-            expect(isSerializableNumericIdentifierCreator(creator)).toBe(true);
-        });
-    }, () => {
-        test("Serialization", () => {
-            const identifier = creator.create(0, true);
-            const serial = "12345678";
-            const serializedIdentifier = identifier + serial;
-            const serials = [serial, "23456789", "34567890", "456789012"];
-            const serializedIdentifiers = serials.map(serial => identifier + serial);
-
-            expect(creator.createSerialized(0, serial, true)).toBe(serializedIdentifier);
-            expect(creator.concatenate(identifier, serial)).toBe(serializedIdentifier);
-            expect(Array.from(creator.createSerialized(0, serials, true))).toStrictEqual(serializedIdentifiers);
-            expect(Array.from(creator.concatenate(identifier, serials))).toStrictEqual(serializedIdentifiers);
-
-            const fullLengthSerial = "0".repeat(creator.serialComponentLength);
-            const fullLengthPlusOneSerial = fullLengthSerial + "0";
-            const fullLengthPlusOneSerialErrorMessage = `Length ${creator.serialComponentLength + 1} of serial component must be less than or equal to ${creator.serialComponentLength}`;
-
-            expect(() => creator.createSerialized(0, fullLengthSerial, true)).not.toThrow(RangeError);
-            expect(() => creator.concatenate(identifier, fullLengthSerial)).not.toThrow(RangeError);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthSerial], true))).not.toThrow(RangeError);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthSerial]))).not.toThrow(RangeError);
-            expect(() => creator.createSerialized(0, fullLengthPlusOneSerial, true)).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => creator.concatenate(identifier, fullLengthPlusOneSerial)).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
-
-            let invalidSerial: string;
-
-            switch (creator.serialComponentCharacterSet) {
-                case ContentCharacterSets.Numeric:
-                    invalidSerial = "1234A5678";
-                    break;
-
-                case ContentCharacterSets.AI82:
-                    invalidSerial = "ABCD~1234";
-                    break;
-
-                case ContentCharacterSets.AI39:
-                    invalidSerial = "ABCD%1234";
-                    break;
-            }
-
-            const invalidSerialErrorMessage = `Invalid character '${invalidSerial.charAt(4)}' at position 5 of serial component`;
-
-            expect(() => creator.createSerialized(0, invalidSerial, true)).toThrow(invalidSerialErrorMessage);
-            expect(() => creator.concatenate(identifier, invalidSerial)).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, invalidSerial]))).toThrow(invalidSerialErrorMessage);
+            expect(isNonSerializableNumericIdentifierCreator(creator)).toBe(true);
         });
     });
 }

package/test/numeric-identifier-creator.ts

@@ -62,8 +62,8 @@ export function testNumericIdentifierCreator<TNumericIdentifierType extends Nume
             expect(index).toBe(referenceCount);
             expect(sequenceIterator.next().value).toBeUndefined();
 
-            const randomValues = new Array<number>();
-            const identifiers = new Array<string>();
+            const randomValues: number[] = [];
+            const identifiers: string[] = [];
 
             for (let i = 0; i < 1000; i++) {
                 const randomValue = Math.floor(Math.random() * creator.capacity);
@@ -99,8 +99,8 @@ export function testNumericIdentifierCreator<TNumericIdentifierType extends Nume
             expect(sequential).toBe(false);
             expect(index).toBe(sparseReferenceCount);
 
-            const randomValues = new Array<number>();
-            const identifiers = new Array<string>();
+            const randomValues: number[] = [];
+            const identifiers: string[] = [];
 
             for (let i = 0; i < 1000; i++) {
                 const randomValue = Math.floor(Math.random() * creator.capacity);

package/test/prefix-manager.test.ts

@@ -15,7 +15,7 @@ describe("Prefix manager", () => {
 
         const gtin14 = prefixManager.gtinCreator.createGTIN14("5", 0);
 
-        expect(gtin14.startsWith("5" + prefixManager.gs1CompanyPrefix)).toBe(true);
+        expect(gtin14.startsWith(`5${prefixManager.gs1CompanyPrefix}`)).toBe(true);
         expect(gtin14.length).toBe(14);
     }
 
@@ -64,7 +64,7 @@ describe("Prefix manager", () => {
 
         expect(prefixManager.prefixType).toBe(PrefixTypes.UPCCompanyPrefix);
         expect(prefixManager.prefix).toBe("614141");
-        expect(prefixManager.gs1CompanyPrefix).toBe("0" + prefixManager.prefix);
+        expect(prefixManager.gs1CompanyPrefix).toBe(`0${prefixManager.prefix}`);
         expect(prefixManager.upcCompanyPrefix).toBe(prefixManager.prefix);
         expect(prefixManager.gs18Prefix).toBeUndefined();
 
@@ -79,7 +79,7 @@ describe("Prefix manager", () => {
 
         expect(prefixManager.prefixType).toBe(PrefixTypes.GS18Prefix);
         expect(prefixManager.prefix).toBe("952");
-        expect(prefixManager.gs1CompanyPrefix).toBe("00000" + prefixManager.prefix);
+        expect(prefixManager.gs1CompanyPrefix).toBe(`00000${prefixManager.prefix}`);
         expect(prefixManager.upcCompanyPrefix).toBeUndefined();
         expect(prefixManager.gs18Prefix).toBe(prefixManager.prefix);
 
@@ -96,8 +96,8 @@ describe("Prefix manager", () => {
 
         expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952123A56789")).toThrow("Invalid character 'A' at position 7 of GS1 Company Prefix");
 
-        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "61414")).toThrow("Length 5 of U.P.C. Company Prefix must be greater than or equal to 6");
-        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "614141")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "6141")).toThrow("Length 4 of U.P.C. Company Prefix must be greater than or equal to 5");
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "61414")).not.toThrow(RangeError);
         expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "61414112345")).not.toThrow(RangeError);
         expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "614141123456")).toThrow("Length 12 of U.P.C. Company Prefix must be less than or equal to 11");
         expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "000614")).not.toThrow(RangeError);

package/test/serializable-numeric-identifier-creator.ts

@@ -13,29 +13,42 @@ export function testSerializableNumericIdentifierCreator(creator: SerializableNu
         });
     }, () => {
         test("Serialization", () => {
-            const identifier = creator.create(0, true);
-            const serial = "12345678";
-            const serializedIdentifier = identifier + serial;
-            const serials = [serial, "23456789", "34567890", "456789012"];
-            const serializedIdentifiers = serials.map(serial => identifier + serial);
+            const baseIdentifier = creator.create(0, true);
+            const serialComponent = "12345678";
+            const serializedIdentifier = baseIdentifier + serialComponent;
+            const serialComponents = [serialComponent, "23456789", "34567890", "456789012"];
+            const serializedIdentifiers = serialComponents.map(serial => baseIdentifier + serial);
 
-            expect(creator.createSerialized(0, serial, true)).toBe(serializedIdentifier);
-            expect(creator.concatenate(identifier, serial)).toBe(serializedIdentifier);
-            expect(Array.from(creator.createSerialized(0, serials, true))).toStrictEqual(serializedIdentifiers);
-            expect(Array.from(creator.concatenate(identifier, serials))).toStrictEqual(serializedIdentifiers);
+            expect(creator.split(baseIdentifier)).toStrictEqual({
+                baseIdentifier,
+                serialComponent: ""
+            });
+
+            expect(creator.createSerialized(0, serialComponent, true)).toBe(serializedIdentifier);
+            expect(creator.split(creator.createSerialized(0, serialComponent, true))).toStrictEqual({
+                baseIdentifier,
+                serialComponent
+            });
+            expect(creator.concatenate(baseIdentifier, serialComponent)).toBe(serializedIdentifier);
+            expect(creator.split(creator.concatenate(baseIdentifier, serialComponent))).toStrictEqual({
+                baseIdentifier,
+                serialComponent
+            });
+            expect(Array.from(creator.createSerialized(0, serialComponents, true))).toStrictEqual(serializedIdentifiers);
+            expect(Array.from(creator.concatenate(baseIdentifier, serialComponents))).toStrictEqual(serializedIdentifiers);
 
             const fullLengthSerial = "0".repeat(creator.serialComponentLength);
-            const fullLengthPlusOneSerial = fullLengthSerial + "0";
+            const fullLengthPlusOneSerial = `${fullLengthSerial}0`;
             const fullLengthPlusOneSerialErrorMessage = `Length ${creator.serialComponentLength + 1} of serial component must be less than or equal to ${creator.serialComponentLength}`;
 
             expect(() => creator.createSerialized(0, fullLengthSerial, true)).not.toThrow(RangeError);
-            expect(() => creator.concatenate(identifier, fullLengthSerial)).not.toThrow(RangeError);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthSerial], true))).not.toThrow(RangeError);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthSerial]))).not.toThrow(RangeError);
+            expect(() => creator.concatenate(baseIdentifier, fullLengthSerial)).not.toThrow(RangeError);
+            expect(() => Array.from(creator.createSerialized(0, [...serialComponents, fullLengthSerial], true))).not.toThrow(RangeError);
+            expect(() => Array.from(creator.concatenate(baseIdentifier, [...serialComponents, fullLengthSerial]))).not.toThrow(RangeError);
             expect(() => creator.createSerialized(0, fullLengthPlusOneSerial, true)).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => creator.concatenate(identifier, fullLengthPlusOneSerial)).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => creator.concatenate(baseIdentifier, fullLengthPlusOneSerial)).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serialComponents, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(baseIdentifier, [...serialComponents, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
 
             let invalidSerial: string;
 
@@ -56,9 +69,9 @@ export function testSerializableNumericIdentifierCreator(creator: SerializableNu
             const invalidSerialErrorMessage = `Invalid character '${invalidSerial.charAt(4)}' at position 5 of serial component`;
 
             expect(() => creator.createSerialized(0, invalidSerial, true)).toThrow(invalidSerialErrorMessage);
-            expect(() => creator.concatenate(identifier, invalidSerial)).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.createSerialized(0, [...serials, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.concatenate(identifier, [...serials, invalidSerial]))).toThrow(invalidSerialErrorMessage);
+            expect(() => creator.concatenate(baseIdentifier, invalidSerial)).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serialComponents, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(baseIdentifier, [...serialComponents, invalidSerial]))).toThrow(invalidSerialErrorMessage);
         });
     });
 }

package/test/validator.test.ts

@@ -17,9 +17,9 @@ import {
     isSerializableNumericIdentifierValidator,
     LeaderTypes
 } from "../src/index.js";
-import { validateGTINValidator } from "./gtin-validator.test.js";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { validateGTINValidator } from "./gtin-validator.js";
 import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { validateNonSerializableNumericIdentifierValidator } from "./non-serializable-numeric-identifier-validator.js";
 import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 describe("Validators", () => {
@@ -62,14 +62,14 @@ describe("Validators", () => {
         validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN13], false, GTINLengths.GTIN13);
         validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN12], false, GTINLengths.GTIN12);
         validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN8], false, GTINLengths.GTIN8);
-        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GLN, false, IdentifierTypes.GLN, 13, LeaderTypes.None);
-        validateNonGTINNumericIdentifierValidator(IdentifierValidators.SSCC, false, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
+        validateNonSerializableNumericIdentifierValidator(IdentifierValidators.GLN, false, IdentifierTypes.GLN, 13, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(IdentifierValidators.SSCC, false, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
         validateSerializableNumericIdentifierValidator(IdentifierValidators.GRAI, false, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
         validateNonNumericIdentifierValidator(IdentifierValidators.GIAI, false, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GSRN, false, IdentifierTypes.GSRN, 18, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(IdentifierValidators.GSRN, false, IdentifierTypes.GSRN, 18, LeaderTypes.None);
         validateSerializableNumericIdentifierValidator(IdentifierValidators.GDTI, false, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
         validateNonNumericIdentifierValidator(IdentifierValidators.GINC, false, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GSIN, false, IdentifierTypes.GSIN, 17, LeaderTypes.None);
+        validateNonSerializableNumericIdentifierValidator(IdentifierValidators.GSIN, false, IdentifierTypes.GSIN, 17, LeaderTypes.None);
         validateSerializableNumericIdentifierValidator(IdentifierValidators.GCN, false, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
         validateNonNumericIdentifierValidator(IdentifierValidators.CPID, false, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
         validateNonNumericIdentifierValidator(IdentifierValidators.GMN, false, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);

package/test/variable-measure-rcn.test.ts

@@ -1,15 +1,10 @@
 import { describe, expect, test } from "vitest";
-import {
-    GTINCreator,
-    GTINValidator,
-    hasValidCheckDigit,
-    isValidPriceOrWeightCheckDigit,
-    type RCNReference
-} from "../src/index.js";
+import { hasValidCheckDigit, isValidPriceOrWeightCheckDigit, type RCNReference } from "../src/index.js";
+import { VariableMeasure } from "../src/index.js";
 
 describe("Variable measure RCN", () => {
     test("RCN-12", () => {
-        const rcn1 = GTINCreator.createVariableMeasureRCN("2IIIIIVPPPPC", 12345, 4321);
+        const rcn1 = VariableMeasure.createRCN("2IIIIIVPPPPC", 12345, 4321);
 
         expect(rcn1.length).toBe(12);
         expect(rcn1.charAt(0)).toBe("2");
@@ -18,14 +13,14 @@ describe("Variable measure RCN", () => {
         expect(isValidPriceOrWeightCheckDigit(rcn1.substring(7, 11), rcn1.charAt(6))).toBe(true);
         expect(hasValidCheckDigit(rcn1)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2IIIIIVPPPPC", rcn1);
+            VariableMeasure.parseRCN("2IIIIIVPPPPC", rcn1);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("2IIIIIVPPPPC", rcn1)).toEqual({
+        expect(VariableMeasure.parseRCN("2IIIIIVPPPPC", rcn1)).toEqual({
             itemReference: 12345,
             priceOrWeight: 4321
         } satisfies RCNReference);
 
-        const rcn2 = GTINCreator.createVariableMeasureRCN("2IIIIPPPPPVC", 1234, 54321);
+        const rcn2 = VariableMeasure.createRCN("2IIIIPPPPPVC", 1234, 54321);
 
         expect(rcn2.length).toBe(12);
         expect(rcn2.charAt(0)).toBe("2");
@@ -34,14 +29,14 @@ describe("Variable measure RCN", () => {
         expect(isValidPriceOrWeightCheckDigit(rcn2.substring(5, 10), rcn2.charAt(10))).toBe(true);
         expect(hasValidCheckDigit(rcn2)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2IIIIPPPPPVC", rcn2);
+            VariableMeasure.parseRCN("2IIIIPPPPPVC", rcn2);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("2IIIIPPPPPVC", rcn2)).toEqual({
+        expect(VariableMeasure.parseRCN("2IIIIPPPPPVC", rcn2)).toEqual({
             itemReference: 1234,
             priceOrWeight: 54321
         } satisfies RCNReference);
 
-        const rcn3 = GTINCreator.createVariableMeasureRCN("2PPPPPIIIIIC", 12345, 54321);
+        const rcn3 = VariableMeasure.createRCN("2PPPPPIIIIIC", 12345, 54321);
 
         expect(rcn3.length).toBe(12);
         expect(rcn3.charAt(0)).toBe("2");
@@ -49,64 +44,64 @@ describe("Variable measure RCN", () => {
         expect(rcn3.substring(6, 11)).toBe("12345");
         expect(hasValidCheckDigit(rcn3)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIC", rcn3);
+            VariableMeasure.parseRCN("2PPPPPIIIIIC", rcn3);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIC", rcn3)).toEqual({
+        expect(VariableMeasure.parseRCN("2PPPPPIIIIIC", rcn3)).toEqual({
             itemReference: 12345,
             priceOrWeight: 54321
         } satisfies RCNReference);
 
-        expect(() => GTINCreator.createVariableMeasureRCN("3PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("20PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("3PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("20PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
 
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "2543211234540");
+            VariableMeasure.parseRCN("3PPPPPIIIIIC", "2543211234540");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "25432112345");
+            VariableMeasure.parseRCN("3PPPPPIIIIIC", "25432112345");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "254321123454");
+            VariableMeasure.parseRCN("3PPPPPIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("20PPPPPIIIIC", "254321123454");
+            VariableMeasure.parseRCN("20PPPPPIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIII", "254321123454");
+            VariableMeasure.parseRCN("2PPPPPIIIIII", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIKC", "254321123454");
+            VariableMeasure.parseRCN("2PPPPPIIIIKC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIPIIC", "254321123454");
+            VariableMeasure.parseRCN("2PPPPPIIPIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPIPPIIIIIC", "254321123454");
+            VariableMeasure.parseRCN("2PPIPPIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIC", "25432112345");
+            VariableMeasure.parseRCN("2PPPPPIIIIC", "25432112345");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIIC", "2543211234540");
+            VariableMeasure.parseRCN("2PPPPPIIIIIIC", "2543211234540");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2PPPPPPPPPPC", "254321123454");
+            VariableMeasure.parseRCN("2PPPPPPPPPPC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("2IIIIIIIIIIC", "254321123454");
+            VariableMeasure.parseRCN("2IIIIIIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
     });
 
     test("RCN-13", () => {
-        const rcn1 = GTINCreator.createVariableMeasureRCN("24IIIIIVPPPPC", 12345, 4321);
+        const rcn1 = VariableMeasure.createRCN("24IIIIIVPPPPC", 12345, 4321);
 
         expect(rcn1.length).toBe(13);
         expect(rcn1.substring(0, 2)).toBe("24");
@@ -115,14 +110,14 @@ describe("Variable measure RCN", () => {
         expect(isValidPriceOrWeightCheckDigit(rcn1.substring(8, 12), rcn1.charAt(7))).toBe(true);
         expect(hasValidCheckDigit(rcn1)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("24IIIIIVPPPPC", rcn1);
+            VariableMeasure.parseRCN("24IIIIIVPPPPC", rcn1);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("24IIIIIVPPPPC", rcn1)).toEqual({
+        expect(VariableMeasure.parseRCN("24IIIIIVPPPPC", rcn1)).toEqual({
             itemReference: 12345,
             priceOrWeight: 4321
         } satisfies RCNReference);
 
-        const rcn2 = GTINCreator.createVariableMeasureRCN("21IIIIPPPPPVC", 1234, 54321);
+        const rcn2 = VariableMeasure.createRCN("21IIIIPPPPPVC", 1234, 54321);
 
         expect(rcn2.length).toBe(13);
         expect(rcn2.substring(0, 2)).toBe("21");
@@ -131,14 +126,14 @@ describe("Variable measure RCN", () => {
         expect(isValidPriceOrWeightCheckDigit(rcn2.substring(6, 11), rcn2.charAt(11))).toBe(true);
         expect(hasValidCheckDigit(rcn2)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("21IIIIPPPPPVC", rcn2);
+            VariableMeasure.parseRCN("21IIIIPPPPPVC", rcn2);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("21IIIIPPPPPVC", rcn2)).toEqual({
+        expect(VariableMeasure.parseRCN("21IIIIPPPPPVC", rcn2)).toEqual({
             itemReference: 1234,
             priceOrWeight: 54321
         } satisfies RCNReference);
 
-        const rcn3 = GTINCreator.createVariableMeasureRCN("27PPPPPIIIIIC", 12345, 54321);
+        const rcn3 = VariableMeasure.createRCN("27PPPPPIIIIIC", 12345, 54321);
 
         expect(rcn3.length).toBe(13);
         expect(rcn3.substring(0, 2)).toBe("27");
@@ -146,56 +141,56 @@ describe("Variable measure RCN", () => {
         expect(rcn3.substring(7, 12)).toBe("12345");
         expect(hasValidCheckDigit(rcn3)).toBe(true);
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("27PPPPPIIIIIC", rcn3);
+            VariableMeasure.parseRCN("27PPPPPIIIIIC", rcn3);
         }).not.toThrow(RangeError);
-        expect(GTINValidator.parseVariableMeasureRCN("27PPPPPIIIIIC", rcn3)).toEqual({
+        expect(VariableMeasure.parseRCN("27PPPPPIIIIIC", rcn3)).toEqual({
             itemReference: 12345,
             priceOrWeight: 54321
         } satisfies RCNReference);
 
-        expect(() => GTINCreator.createVariableMeasureRCN("30PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("20PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("21PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("22PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("23PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("24PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("25PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("26PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
-        expect(() => GTINCreator.createVariableMeasureRCN("27IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("30PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("2PPPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("20PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("21PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("22PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("23PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("24PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("25PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("26PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => VariableMeasure.createRCN("27IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
 
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "27543211234570");
+            VariableMeasure.parseRCN("30PPPPPIIIIIC", "27543211234570");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "275432112345");
+            VariableMeasure.parseRCN("30PPPPPIIIIIC", "275432112345");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "2754321123457");
+            VariableMeasure.parseRCN("30PPPPPIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("20PPPPPIIIIII", "2754321123457");
+            VariableMeasure.parseRCN("20PPPPPIIIIII", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("21PPPPPIIIIKC", "2754321123457");
+            VariableMeasure.parseRCN("21PPPPPIIIIKC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("22PPPPPIIPIIC", "2754321123457");
+            VariableMeasure.parseRCN("22PPPPPIIPIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("23PPIPPIIIIIC", "2754321123457");
+            VariableMeasure.parseRCN("23PPIPPIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("24PPPPPIIIIC", "275432112345");
+            VariableMeasure.parseRCN("24PPPPPIIIIC", "275432112345");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("25PPPPPIIIIIIC", "27543211234570");
+            VariableMeasure.parseRCN("25PPPPPIIIIIIC", "27543211234570");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("26PPPPPPPPPPC", "2754321123457");
+            VariableMeasure.parseRCN("26PPPPPPPPPPC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINValidator.parseVariableMeasureRCN("27IIIIIIIIIIC", "2754321123457");
+            VariableMeasure.parseRCN("27IIIIIIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
     });
 });