@aidc-toolkit/gs1 0.9.0 → 0.9.2

package/src/locale/i18next.d.ts

@@ -1,6 +1,12 @@
 import type { localeStrings } from "./en/locale_strings.js";
 
+/**
+ * Internationalization module.
+ */
 declare module "i18next" {
+    /**
+     * Custom type options for this package.
+     */
     interface CustomTypeOptions {
         resources: {
             // Extract the type from the English locale strings object.

package/test/check.test.ts

@@ -1,6 +1,6 @@
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
-import { I18NEnvironment, i18nInit } from "../../core/dist/index.js";
 import {
     checkCharacterPair,
     checkDigit,
@@ -40,48 +40,42 @@ describe("Check digit", () => {
 });
 
 describe("Price/weight check digit", () => {
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function weight2Minus(characterIndex: number): number {
         const product = characterIndex * 2;
 
         return (product - Math.trunc(product / 10)) % 10;
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function weight3(characterIndex: number): number {
         return characterIndex * 3 % 10;
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function weight5Plus(characterIndex: number): number {
         const product = characterIndex * 5;
 
         return (product + Math.trunc(product / 10)) % 10;
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function weight5Minus(characterIndex: number): number {
         const product = characterIndex * 5;
 
         return (product - Math.trunc(product / 10)) % 10;
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function testFourDigitPriceWeightCheckDigit(s: string): void {
-        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s);
+        // All character indexes are known to be defined.
+        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s) as number[];
 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const sum = weight2Minus(characterIndexes[0]!) + weight2Minus(characterIndexes[1]!) + weight3(characterIndexes[2]!) + weight5Minus(characterIndexes[3]!);
+        const sum = weight2Minus(characterIndexes[0]) + weight2Minus(characterIndexes[1]) + weight3(characterIndexes[2]) + weight5Minus(characterIndexes[3]);
 
         expect(fourDigitPriceWeightCheckDigit(s)).toBe(NUMERIC_CREATOR.character(sum * 3 % 10));
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function testFiveDigitPriceWeightCheckDigit(s: string): void {
-        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s);
+        // All character indexes are known to be defined.
+        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s) as number[];
 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const sum = weight5Plus(characterIndexes[0]!) + weight2Minus(characterIndexes[1]!) + weight5Minus(characterIndexes[2]!) + weight5Plus(characterIndexes[3]!) + weight2Minus(characterIndexes[4]!);
+        const sum = weight5Plus(characterIndexes[0]) + weight2Minus(characterIndexes[1]) + weight5Minus(characterIndexes[2]) + weight5Plus(characterIndexes[3]) + weight2Minus(characterIndexes[4]);
 
         expect(weight5Minus(Number(fiveDigitPriceWeightCheckDigit(s)))).toBe(9 - (sum + 9) % 10);
     }

package/test/idkey.test.ts

@@ -1,5 +1,5 @@
 import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
-import { CharacterSetCreator, Exclusion, IterationHelper, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
+import { CharacterSetCreator, Exclusion, NUMERIC_CREATOR, Sequencer } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
 import {
     AI39_CREATOR,
@@ -42,7 +42,6 @@ import {
 
 await i18nInit(I18NEnvironment.CLI, true);
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function creatorFor(characterSet: CharacterSet): CharacterSetCreator {
     let creator: CharacterSetCreator;
 
@@ -63,14 +62,12 @@ function creatorFor(characterSet: CharacterSet): CharacterSetCreator {
     return creator;
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateIdentificationKeyValidator(creator: IdentificationKeyValidator, identificationKeyType: IdentificationKeyType, prefixType: PrefixType, length: number): void {
     expect(creator.identificationKeyType).toBe(identificationKeyType);
     expect(creator.prefixType).toBe(prefixType);
     expect(creator.length).toBe(length);
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateNumericIdentificationKeyValidator(validator: NumericIdentificationKeyValidator, isCreator: boolean, identificationKeyType: IdentificationKeyType, prefixType: PrefixType, length: number, leaderType: LeaderType): void {
     validateIdentificationKeyValidator(validator, identificationKeyType, prefixType, length);
 
@@ -83,7 +80,6 @@ function validateNumericIdentificationKeyValidator(validator: NumericIdentificat
     }
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinType: GTINType): void {
     let prefixType: PrefixType;
 
@@ -109,12 +105,10 @@ function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gti
     expect(validator.gtinType).toBe(gtinType);
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateNonGTINNumericIdentificationKeyValidator<T extends NonGTINNumericIdentificationKeyValidator>(validator: T, isCreator: boolean, identificationKeyType: IdentificationKeyType, length: number, leaderType: LeaderType): void {
     validateNumericIdentificationKeyValidator(validator, isCreator, identificationKeyType, PrefixType.GS1CompanyPrefix, length, leaderType);
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateSerializableNumericIdentificationKeyValidator(validator: SerializableNumericIdentificationKeyValidator, isCreator: boolean, identificationKeyType: IdentificationKeyType, length: number, leaderType: LeaderType, serialLength: number, serialCharacterSet: CharacterSet): void {
     validateNonGTINNumericIdentificationKeyValidator(validator, isCreator, identificationKeyType, length, leaderType);
 
@@ -129,7 +123,6 @@ function validateSerializableNumericIdentificationKeyValidator(validator: Serial
     }
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateNonNumericIdentificationKeyValidator(validator: NonNumericIdentificationKeyValidator, isCreator: boolean, identificationKeyType: IdentificationKeyType, length: number, referenceCharacterSet: CharacterSet, requiresCheckCharacterPair: boolean): void {
     validateIdentificationKeyValidator(validator, identificationKeyType, PrefixType.GS1CompanyPrefix, length);
 
@@ -169,7 +162,6 @@ describe("Validators", () => {
     });
 });
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function validateIdentificationKeyCreators(prefixManager: PrefixManager): void {
     let gtinType: GTINType;
 
@@ -190,9 +182,23 @@ function validateIdentificationKeyCreators(prefixManager: PrefixManager): void {
             break;
     }
 
+    expect(prefixManager.gtinCreator).toBe(prefixManager.gtinCreator);
+
     validateGTINValidator(prefixManager.gtinCreator, true, gtinType);
 
     if (prefixManager.prefixType !== PrefixType.GS18Prefix) {
+        expect(prefixManager.glnCreator).toBe(prefixManager.glnCreator);
+        expect(prefixManager.ssccCreator).toBe(prefixManager.ssccCreator);
+        expect(prefixManager.graiCreator).toBe(prefixManager.graiCreator);
+        expect(prefixManager.giaiCreator).toBe(prefixManager.giaiCreator);
+        expect(prefixManager.gsrnCreator).toBe(prefixManager.gsrnCreator);
+        expect(prefixManager.gdtiCreator).toBe(prefixManager.gdtiCreator);
+        expect(prefixManager.gincCreator).toBe(prefixManager.gincCreator);
+        expect(prefixManager.gsinCreator).toBe(prefixManager.gsinCreator);
+        expect(prefixManager.gcnCreator).toBe(prefixManager.gcnCreator);
+        expect(prefixManager.cpidCreator).toBe(prefixManager.cpidCreator);
+        expect(prefixManager.gmnCreator).toBe(prefixManager.gmnCreator);
+
         validateNonGTINNumericIdentificationKeyValidator(prefixManager.glnCreator, true, IdentificationKeyType.GLN, 13, LeaderType.None);
         validateNonGTINNumericIdentificationKeyValidator(prefixManager.ssccCreator, true, IdentificationKeyType.SSCC, 18, LeaderType.ExtensionDigit);
         validateSerializableNumericIdentificationKeyValidator(prefixManager.graiCreator, true, IdentificationKeyType.GRAI, 13, LeaderType.None, 16, CharacterSet.AI82);
@@ -222,7 +228,6 @@ function validateIdentificationKeyCreators(prefixManager: PrefixManager): void {
 describe("Prefix manager", () => {
     let prefixManager: PrefixManager;
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function validateGTINStartsWithPrefix(length: number): void {
         expect(prefixManager.gtinCreator.length).toBe(length);
 
@@ -237,7 +242,6 @@ describe("Prefix manager", () => {
         expect(gtin14.length).toBe(14);
     }
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
     function validateNonGTINStartsWithGS1CompanyPrefix(): void {
         const gln = prefixManager.glnCreator.create(0);
 
@@ -373,8 +377,8 @@ describe("Sparse creation", () => {
 
     prefixManager.tweakFactor = 0;
 
-    const sparseGTINs = Array.from(prefixManager.gtinCreator.createSequence(0, 10, true));
-    const straightGTINs = Array.from(prefixManager.gtinCreator.createSequence(0, 10));
+    const sparseGTINs = Array.from(prefixManager.gtinCreator.create(new Sequencer(0, 10), true));
+    const straightGTINs = Array.from(prefixManager.gtinCreator.create(new Sequencer(0, 10)));
 
     test("Tweak factor 0", () => {
         expect(sparseGTINs).toStrictEqual(straightGTINs);
@@ -383,14 +387,12 @@ describe("Sparse creation", () => {
     prefixManager.resetTweakFactor();
 });
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testIdentificationKeyCreatorCallback(callback?: () => void): void {
     if (callback !== undefined) {
         callback();
     }
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCreator, preTestCallback?: () => void, postTestCallback?: () => void): void {
     describe(creator.identificationKeyType === IdentificationKeyType.GTIN ? `${creator.identificationKeyType}-${creator.length}` : creator.identificationKeyType, () => {
         testIdentificationKeyCreatorCallback(preTestCallback);
@@ -405,7 +407,6 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
         const referenceSubstringStart = prefixSubstringEnd;
         const referenceSubstringEnd = referenceSubstringStart + referenceLength - prefixSubstringStart;
 
-        // eslint-disable-next-line jsdoc/require-jsdoc
         function validate(identificationKey: string, index: number, sparse: boolean): void {
             expect(() => {
                 creator.validate(identificationKey);
@@ -421,11 +422,11 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
             expect(creator.referenceLength).toBe(referenceLength);
             expect(creator.capacity).toBe(Number(CharacterSetCreator.powerOf10(referenceLength)));
 
-            const sequenceIterator = creator.createSequence(0, referenceCount)[Symbol.iterator]();
+            const sequenceIterator = Iterator.from(creator.create(new Sequencer(0, referenceCount)));
 
             let allCount = 0;
 
-            IterationHelper.from(creator.createAll()).forEach((identificationKey, index) => {
+            Iterator.from(creator.createAll()).forEach((identificationKey, index) => {
                 validate(identificationKey, index, false);
 
                 expect(Number((hasExtensionDigit ? identificationKey.charAt(0) : "") + identificationKey.substring(referenceSubstringStart, referenceSubstringEnd))).toBe(index);
@@ -447,7 +448,7 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
                 identificationKeys.push(creator.create(randomValue));
             }
 
-            expect(Array.from(creator.createMultiple(randomValues))).toStrictEqual(identificationKeys);
+            expect(Array.from(creator.create(randomValues))).toStrictEqual(identificationKeys);
         });
 
         test("Sparse", () => {
@@ -460,7 +461,7 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
 
             let sequenceCount = 0;
 
-            IterationHelper.from(creator.createSequence(0, sparseReferenceCount, true)).forEach((identificationKey, index) => {
+            Iterator.from(creator.create(new Sequencer(0, sparseReferenceCount), true)).forEach((identificationKey, index) => {
                 validate(identificationKey, index, true);
 
                 sequential = sequential && Number((hasExtensionDigit ? identificationKey.charAt(0) : "") + identificationKey.substring(referenceSubstringStart, referenceSubstringEnd)) === index;
@@ -484,7 +485,7 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
                 identificationKeys.push(creator.create(randomValue, true));
             }
 
-            expect(Array.from(creator.createMultiple(randomValues, true))).toStrictEqual(identificationKeys);
+            expect(Array.from(creator.create(randomValues, true))).toStrictEqual(identificationKeys);
         });
 
         test("Validation position", () => {
@@ -505,11 +506,18 @@ function testNumericIdentificationKeyCreator(creator: NumericIdentificationKeyCr
             }).toThrow("Invalid character 'O' at position 3");
         });
 
+        test("Position offset", () => {
+            expect(() => {
+                creator.validate(creator.create(0), {
+                    positionOffset: 4
+                });
+            }).not.toThrow(RangeError);
+        });
+
         testIdentificationKeyCreatorCallback(postTestCallback);
     });
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testGTINCreator(creator: GTINCreator): void {
     testNumericIdentificationKeyCreator(creator, () => {
         test("Length", () => {
@@ -538,7 +546,6 @@ function testGTINCreator(creator: GTINCreator): void {
         const referenceSubstringStart = prefixSubstringEnd;
         const referenceSubstringEnd = referenceSubstringStart + referenceLength;
 
-        // eslint-disable-next-line jsdoc/require-jsdoc
         function validate(gtin: string, index: number, sparse: boolean): void {
             expect(() => {
                 GTINCreator.validateGTIN14(gtin);
@@ -555,7 +562,7 @@ function testGTINCreator(creator: GTINCreator): void {
         test("GTIN-14 straight", () => {
             let sequenceCount = 0;
 
-            IterationHelper.from(creator.createGTIN14Sequence("5", 0, referenceCount)).forEach((gtin, index) => {
+            Iterator.from(creator.createGTIN14("5", new Sequencer(0, referenceCount))).forEach((gtin, index) => {
                 expect(Number(gtin.substring(referenceSubstringStart, referenceSubstringEnd))).toBe(index);
 
                 validate(gtin, index, false);
@@ -575,7 +582,7 @@ function testGTINCreator(creator: GTINCreator): void {
                 identificationKeys.push(creator.createGTIN14("5", randomValue));
             }
 
-            expect(Array.from(creator.createGTIN14Multiple("5", randomValues))).toStrictEqual(identificationKeys);
+            expect(Array.from(creator.createGTIN14("5", randomValues))).toStrictEqual(identificationKeys);
         });
 
         test("GTIN-14 sparse", () => {
@@ -588,7 +595,7 @@ function testGTINCreator(creator: GTINCreator): void {
 
             let sequenceCount = 0;
 
-            IterationHelper.from(creator.createGTIN14Sequence("5", 0, sparseReferenceCount, true)).forEach((gtin, index) => {
+            Iterator.from(creator.createGTIN14("5", new Sequencer(0, sparseReferenceCount), true)).forEach((gtin, index) => {
                 sequential = sequential && Number(gtin.substring(referenceSubstringStart, referenceSubstringEnd)) === index;
 
                 validate(gtin, index, true);
@@ -612,7 +619,7 @@ function testGTINCreator(creator: GTINCreator): void {
                 identificationKeys.push(creator.createGTIN14("5", randomValue, true));
             }
 
-            expect(Array.from(creator.createGTIN14Multiple("5", randomValues, true))).toStrictEqual(identificationKeys);
+            expect(Array.from(creator.createGTIN14("5", randomValues, true))).toStrictEqual(identificationKeys);
         });
 
         if (creator.gtinType === GTINType.GTIN12) {
@@ -746,7 +753,6 @@ function testGTINCreator(creator: GTINCreator): void {
     });
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testGTINValidationAndNormalization(): void {
     describe("GTIN validation and normalization", () => {
         test("Validation", () => {
@@ -861,12 +867,10 @@ function testGTINValidationAndNormalization(): void {
     });
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testNonGTINNumericIdentificationKeyCreator(creator: NonGTINNumericIdentificationKeyCreator, preTestCallback?: () => void, postTestCallback?: () => void): void {
     testNumericIdentificationKeyCreator(creator, preTestCallback, postTestCallback);
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testSerializableNumericIdentificationKeyCreator(creator: SerializableNumericIdentificationKeyCreator): void {
     testNonGTINNumericIdentificationKeyCreator(creator, undefined, () => {
         test("Serialization", () => {
@@ -878,8 +882,8 @@ function testSerializableNumericIdentificationKeyCreator(creator: SerializableNu
 
             expect(creator.createSerialized(0, serial, true)).toBe(serializedIdentificationKey);
             expect(creator.concatenate(identificationKey, serial)).toBe(serializedIdentificationKey);
-            expect(Array.from(creator.createMultipleSerialized(0, serials, true))).toStrictEqual(serializedIdentificationKeys);
-            expect(Array.from(creator.concatenateMultiple(identificationKey, serials))).toStrictEqual(serializedIdentificationKeys);
+            expect(Array.from(creator.createSerialized(0, serials, true))).toStrictEqual(serializedIdentificationKeys);
+            expect(Array.from(creator.concatenate(identificationKey, serials))).toStrictEqual(serializedIdentificationKeys);
 
             const fullLengthSerial = "0".repeat(creator.serialComponentLength);
             const fullLengthPlusOneSerial = fullLengthSerial + "0";
@@ -887,12 +891,12 @@ function testSerializableNumericIdentificationKeyCreator(creator: SerializableNu
 
             expect(() => creator.createSerialized(0, fullLengthSerial, true)).not.toThrow(RangeError);
             expect(() => creator.concatenate(identificationKey, fullLengthSerial)).not.toThrow(RangeError);
-            expect(() => Array.from(creator.createMultipleSerialized(0, [...serials, fullLengthSerial], true))).not.toThrow(RangeError);
-            expect(() => Array.from(creator.concatenateMultiple(identificationKey, [...serials, fullLengthSerial]))).not.toThrow(RangeError);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthSerial], true))).not.toThrow(RangeError);
+            expect(() => Array.from(creator.concatenate(identificationKey, [...serials, fullLengthSerial]))).not.toThrow(RangeError);
             expect(() => creator.createSerialized(0, fullLengthPlusOneSerial, true)).toThrow(fullLengthPlusOneSerialErrorMessage);
             expect(() => creator.concatenate(identificationKey, fullLengthPlusOneSerial)).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.createMultipleSerialized(0, [...serials, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
-            expect(() => Array.from(creator.concatenateMultiple(identificationKey, [...serials, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(identificationKey, [...serials, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
 
             let invalidSerial: string;
 
@@ -914,15 +918,14 @@ function testSerializableNumericIdentificationKeyCreator(creator: SerializableNu
 
             expect(() => creator.createSerialized(0, invalidSerial, true)).toThrow(invalidSerialErrorMessage);
             expect(() => creator.concatenate(identificationKey, invalidSerial)).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.createMultipleSerialized(0, [...serials, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
-            expect(() => Array.from(creator.concatenateMultiple(identificationKey, [...serials, invalidSerial]))).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(identificationKey, [...serials, invalidSerial]))).toThrow(invalidSerialErrorMessage);
         });
     });
 }
 
 const TEST_REFERENCE_LENGTH = 2;
 
-// eslint-disable-next-line jsdoc/require-jsdoc
 function testNonNumericIdentificationKeyCreator<T extends NonNumericIdentificationKeyCreator>(creator: T): void {
     describe(creator.identificationKeyType, () => {
         const prefix = creator.prefix;
@@ -937,12 +940,12 @@ function testNonNumericIdentificationKeyCreator<T extends NonNumericIdentificati
 
             let sequenceCount = 0;
 
-            IterationHelper.from(creator.createMultiple(creator.referenceCreator.createSequence(TEST_REFERENCE_LENGTH, 0, referenceCount))).forEach((identificationKey, index) => {
+            Iterator.from(creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequencer(0, referenceCount)))).forEach((identificationKey, index) => {
                 expect(() => {
                     creator.validate(identificationKey);
                 }).not.toThrow(RangeError);
 
-                expect(Number(creator.referenceCreator.value(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd)))).toBe(index);
+                expect(Number(creator.referenceCreator.valueFor(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd)))).toBe(index);
 
                 expect(identificationKey.length).toBeLessThanOrEqual(creator.length);
                 expect(identificationKey.substring(0, prefixLength)).toBe(prefix);
@@ -961,14 +964,14 @@ function testNonNumericIdentificationKeyCreator<T extends NonNumericIdentificati
 
             let sequenceCount = 0;
 
-            IterationHelper.from(creator.createMultiple(creator.referenceCreator.createSequence(TEST_REFERENCE_LENGTH, 0, referenceCount, Exclusion.None, 123456n))).forEach((identificationKey, index) => {
+            Iterator.from(creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequencer(0, referenceCount), Exclusion.None, 123456n))).forEach((identificationKey, index) => {
                 expect(() => {
                     creator.validate(identificationKey);
                 }).not.toThrow(RangeError);
 
-                expect(Number(creator.referenceCreator.value(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd), Exclusion.None, 123456n))).toBe(index);
+                expect(Number(creator.referenceCreator.valueFor(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd), Exclusion.None, 123456n))).toBe(index);
 
-                sequential = sequential && Number(creator.referenceCreator.value(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd))) === index;
+                sequential = sequential && Number(creator.referenceCreator.valueFor(identificationKey.substring(referenceSubstringStart, referenceSubstringEnd))) === index;
 
                 expect(identificationKey.length).toBeLessThanOrEqual(creator.length);
                 expect(identificationKey.substring(0, prefixLength)).toBe(prefix);
@@ -983,6 +986,14 @@ function testNonNumericIdentificationKeyCreator<T extends NonNumericIdentificati
             expect(sequenceCount).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/typedoc.json

@@ -6,5 +6,6 @@
   "name": "GS1",
   "entryPoints": [
     "src/index.ts"
-  ]
+  ],
+  "gitRevision": "main"
 }