@aidc-toolkit/gs1 0.9.4 → 0.9.6-beta

package/dist/index.cjs

@@ -0,0 +1,2045 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AI39_CREATOR: () => AI39_CREATOR,
+  AI82_CREATOR: () => AI82_CREATOR,
+  CPID_VALIDATOR: () => CPID_VALIDATOR,
+  CharacterSet: () => CharacterSet,
+  GCN_VALIDATOR: () => GCN_VALIDATOR,
+  GDTI_VALIDATOR: () => GDTI_VALIDATOR,
+  GIAI_VALIDATOR: () => GIAI_VALIDATOR,
+  GINC_VALIDATOR: () => GINC_VALIDATOR,
+  GLN_VALIDATOR: () => GLN_VALIDATOR,
+  GMN_VALIDATOR: () => GMN_VALIDATOR,
+  GRAI_VALIDATOR: () => GRAI_VALIDATOR,
+  GSIN_VALIDATOR: () => GSIN_VALIDATOR,
+  GSRN_VALIDATOR: () => GSRN_VALIDATOR,
+  GTIN12_VALIDATOR: () => GTIN12_VALIDATOR,
+  GTIN13_VALIDATOR: () => GTIN13_VALIDATOR,
+  GTIN8_VALIDATOR: () => GTIN8_VALIDATOR,
+  GTINCreator: () => GTINCreator,
+  GTINLevel: () => GTINLevel,
+  GTINType: () => GTINType,
+  GTINValidator: () => GTINValidator,
+  GTIN_VALIDATORS: () => GTIN_VALIDATORS,
+  IdentificationKeyType: () => IdentificationKeyType,
+  LeaderType: () => LeaderType,
+  NonGTINNumericIdentificationKeyCreator: () => NonGTINNumericIdentificationKeyCreator,
+  NonGTINNumericIdentificationKeyValidator: () => NonGTINNumericIdentificationKeyValidator,
+  NonNumericIdentificationKeyCreator: () => NonNumericIdentificationKeyCreator,
+  NonNumericIdentificationKeyValidator: () => NonNumericIdentificationKeyValidator,
+  PrefixManager: () => PrefixManager,
+  PrefixType: () => PrefixType,
+  SSCC_VALIDATOR: () => SSCC_VALIDATOR,
+  SerializableNumericIdentificationKeyCreator: () => SerializableNumericIdentificationKeyCreator,
+  SerializableNumericIdentificationKeyValidator: () => SerializableNumericIdentificationKeyValidator,
+  checkCharacterPair: () => checkCharacterPair,
+  checkDigit: () => checkDigit,
+  checkDigitSum: () => checkDigitSum,
+  fiveDigitPriceWeightCheckDigit: () => fiveDigitPriceWeightCheckDigit,
+  fourDigitPriceWeightCheckDigit: () => fourDigitPriceWeightCheckDigit,
+  hasValidCheckCharacterPair: () => hasValidCheckCharacterPair,
+  hasValidCheckDigit: () => hasValidCheckDigit
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/character_set.ts
+var import_utility = require("@aidc-toolkit/utility");
+var AI82_CREATOR = new import_utility.CharacterSetCreator([
+  "!",
+  '"',
+  "%",
+  "&",
+  "'",
+  "(",
+  ")",
+  "*",
+  "+",
+  ",",
+  "-",
+  ".",
+  "/",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  ":",
+  ";",
+  "<",
+  "=",
+  ">",
+  "?",
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "_",
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z"
+], import_utility.Exclusion.AllNumeric);
+var AI39_CREATOR = new import_utility.CharacterSetCreator([
+  "#",
+  "-",
+  "/",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z"
+], import_utility.Exclusion.AllNumeric);
+
+// src/check.ts
+var import_utility2 = require("@aidc-toolkit/utility");
+
+// src/locale/i18n.ts
+var import_core = require("@aidc-toolkit/core");
+
+// src/locale/en/locale_strings.ts
+var localeStrings = {
+  Check: {
+    lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length}} of string for check character pair must be less than or equal to {{maximumLength}}"
+  },
+  IdentificationKey: {
+    identificationKeyTypeLength: "{{identificationKeyType}} must be {{length}} digits long",
+    invalidCheckDigit: "Invalid check digit",
+    invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long",
+    invalidGTIN14Length: "GTIN must be 14 digits long",
+    invalidZeroSuppressedGTIN12: "Invalid zero-suppressed GTIN-12",
+    invalidZeroSuppressibleGTIN12: "GTIN-12 not zero-suppressible",
+    invalidZeroSuppressedGTIN12AsGTIN13: "Invalid zero-suppressed GTIN-12 as GTIN-13",
+    invalidZeroSuppressedGTIN12AsGTIN14: "Invalid zero-suppressed GTIN-12 as GTIN-14",
+    invalidGTIN13AtRetail: "GTIN-13 at retail consumer trade item level can't start with zero",
+    invalidGTINAtRetail: "GTIN not supported at retail consumer trade item level",
+    invalidGTINAtOtherThanRetail: "GTIN not supported at other than retail consumer trade item level",
+    indicatorDigit: "indicator digit",
+    serialComponent: "serial component",
+    reference: "reference",
+    referenceCantBeAllNumeric: "Reference can't be all-numeric",
+    invalidCheckCharacterPair: "Invalid check character pair"
+  },
+  Prefix: {
+    gs1CompanyPrefix: "GS1 Company Prefix",
+    upcCompanyPrefix: "U.P.C. Company Prefix",
+    gs18Prefix: "GS1-8 Prefix",
+    gs1CompanyPrefixCantStartWith0: `GS1 Company Prefix can't start with "0"`,
+    gs1CompanyPrefixCantStartWith00000: `GS1 Company Prefix can't start with "00000"`,
+    gs1CompanyPrefixCantStartWith000000: `GS1 Company Prefix can't start with "000000"`,
+    upcCompanyPrefixCantStartWith0000: `U.P.C. Company Prefix can't start with "0000"`,
+    gs18PrefixCantStartWith0: `GS1-8 Prefix can't start with "0"`,
+    identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} not supported by GS1-8 Prefix"
+  }
+};
+
+// src/locale/fr/locale_strings.ts
+var localeStrings2 = {
+  Check: {
+    lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "La longueur {{length}} de la cha\xEEne pour la paire de caract\xE8res de v\xE9rification doit \xEAtre inf\xE9rieure ou \xE9gale \xE0 {{maximum Length}}"
+  },
+  IdentificationKey: {
+    identificationKeyTypeLength: "{{identificationKeyType}} doit comporter {{length}} chiffres",
+    invalidCheckDigit: "Chiffre de contr\xF4le non valide",
+    invalidGTINLength: "Le GTIN doit comporter 13, 12, 8 ou 14 chiffres",
+    invalidGTIN14Length: "Le GTIN doit comporter 14 chiffres",
+    invalidZeroSuppressedGTIN12: "Code GTIN-12 non valide avec z\xE9ro supprim\xE9",
+    invalidZeroSuppressibleGTIN12: "Le GTIN-12 ne peut pas \xEAtre supprim\xE9 par z\xE9ro",
+    invalidZeroSuppressedGTIN12AsGTIN13: "GTIN-12 non valide avec z\xE9ro supprim\xE9 en tant que GTIN-13",
+    invalidZeroSuppressedGTIN12AsGTIN14: "GTIN-12 non valide avec z\xE9ro supprim\xE9 en tant que GTIN-14",
+    invalidGTIN13AtRetail: "Le GTIN-13 au niveau des articles de consommation au d\xE9tail ne peut pas commencer par z\xE9ro",
+    invalidGTINAtRetail: "Le GTIN n'est pas pris en charge au niveau des articles de consommation au d\xE9tail",
+    invalidGTINAtOtherThanRetail: "Le GTIN n'est pas pris en charge \xE0 d'autres niveaux que ceux des articles de consommation au d\xE9tail",
+    indicatorDigit: "chiffre indicateur",
+    serialComponent: "composant s\xE9rie",
+    reference: "r\xE9f\xE9rence",
+    referenceCantBeAllNumeric: "La r\xE9f\xE9rence ne peut pas \xEAtre enti\xE8rement num\xE9rique",
+    invalidCheckCharacterPair: "Paire de caract\xE8res de contr\xF4le non valide"
+  },
+  Prefix: {
+    gs1CompanyPrefix: "Pr\xE9fixe de l'entreprise GS1",
+    upcCompanyPrefix: "Pr\xE9fixe de l'entreprise U.P.C.",
+    gs18Prefix: "Pr\xE9fixe GS1-8",
+    gs1CompanyPrefixCantStartWith0: `Le pr\xE9fixe de l'entreprise GS1 ne peut pas commencer par "0"`,
+    gs1CompanyPrefixCantStartWith00000: `Le pr\xE9fixe de l'entreprise GS1 ne peut pas commencer par "00000"`,
+    gs1CompanyPrefixCantStartWith000000: `Le pr\xE9fixe de l'entreprise GS1 ne peut pas commencer par "000000"`,
+    upcCompanyPrefixCantStartWith0000: `Le pr\xE9fixe de l'entreprise U.P.C. ne peut pas commencer par "0000"`,
+    gs18PrefixCantStartWith0: 'Le pr\xE9fixe GS1-8 ne peut pas commencer par "0"',
+    identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} non pris en charge par le pr\xE9fixe GS1-8"
+  }
+};
+
+// src/locale/i18n.ts
+var gs1NS = "aidct_gs1";
+(0, import_core.i18nAssertValidResources)(localeStrings, "fr", localeStrings2);
+(0, import_core.i18nAddResourceBundle)("en", gs1NS, localeStrings);
+(0, import_core.i18nAddResourceBundle)("fr", gs1NS, localeStrings2);
+var i18n_default = import_core.i18next;
+
+// src/check.ts
+var THREE_WEIGHT_RESULTS = [
+  0,
+  3,
+  6,
+  9,
+  12,
+  15,
+  18,
+  21,
+  24,
+  27
+];
+var TWO_MINUS_WEIGHT_RESULTS = [
+  0,
+  2,
+  4,
+  6,
+  8,
+  9,
+  1,
+  3,
+  5,
+  7
+];
+var FIVE_PLUS_WEIGHT_RESULTS = [
+  0,
+  5,
+  1,
+  6,
+  2,
+  7,
+  3,
+  8,
+  4,
+  9
+];
+var FIVE_MINUS_WEIGHT_RESULTS = [
+  0,
+  5,
+  9,
+  4,
+  8,
+  3,
+  7,
+  2,
+  6,
+  1
+];
+var INVERSE_FIVE_MINUS_WEIGHT_RESULTS = [
+  0,
+  9,
+  7,
+  5,
+  3,
+  1,
+  8,
+  6,
+  4,
+  2
+];
+function checkDigitSum(exchangeWeights, s) {
+  let weight3 = (s.length + Number(exchangeWeights)) % 2 === 0;
+  return import_utility2.NUMERIC_CREATOR.characterIndexes(s).reduce((accumulator, characterIndex, index) => {
+    if (characterIndex === void 0) {
+      throw new RangeError(`Invalid character '${s.charAt(index)}' at position ${index + 1}`);
+    }
+    weight3 = !weight3;
+    return accumulator + (weight3 ? THREE_WEIGHT_RESULTS[characterIndex] : characterIndex);
+  }, 0);
+}
+function checkDigit(s) {
+  return import_utility2.NUMERIC_CREATOR.character(9 - (checkDigitSum(false, s) + 9) % 10);
+}
+function hasValidCheckDigit(s) {
+  return checkDigitSum(true, s) % 10 === 0;
+}
+function priceWeightSum(weightsResults, s) {
+  if (s.length !== weightsResults.length) {
+    throw new RangeError(`String for price or weight sum must be exactly ${weightsResults.length} characters`);
+  }
+  const characterIndexes = import_utility2.NUMERIC_CREATOR.characterIndexes(s);
+  return characterIndexes.reduce((accumulator, characterIndex, index) => {
+    if (characterIndex === void 0) {
+      throw new RangeError(`Invalid character '${s.charAt(index)}' at position ${index + 1}`);
+    }
+    return accumulator + weightsResults[index][characterIndex];
+  }, 0);
+}
+function fourDigitPriceWeightCheckDigit(s) {
+  return import_utility2.NUMERIC_CREATOR.character(priceWeightSum([TWO_MINUS_WEIGHT_RESULTS, TWO_MINUS_WEIGHT_RESULTS, THREE_WEIGHT_RESULTS, FIVE_MINUS_WEIGHT_RESULTS], s) * 3 % 10);
+}
+function fiveDigitPriceWeightCheckDigit(s) {
+  return import_utility2.NUMERIC_CREATOR.character(INVERSE_FIVE_MINUS_WEIGHT_RESULTS[9 - (priceWeightSum([FIVE_PLUS_WEIGHT_RESULTS, TWO_MINUS_WEIGHT_RESULTS, FIVE_MINUS_WEIGHT_RESULTS, FIVE_PLUS_WEIGHT_RESULTS, TWO_MINUS_WEIGHT_RESULTS], s) + 9) % 10]);
+}
+var CHECK_CHARACTER_WEIGHTS = [
+  107,
+  103,
+  101,
+  97,
+  89,
+  83,
+  79,
+  73,
+  71,
+  67,
+  61,
+  59,
+  53,
+  47,
+  43,
+  41,
+  37,
+  31,
+  29,
+  23,
+  19,
+  17,
+  13,
+  11,
+  7,
+  5,
+  3,
+  2
+];
+var CHECK_CHARACTERS = [
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z"
+];
+function checkCharacterPair(s) {
+  const weightIndexStart = CHECK_CHARACTER_WEIGHTS.length - s.length;
+  if (weightIndexStart < 0) {
+    throw new RangeError(i18n_default.t("Check.lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo", {
+      ns: gs1NS,
+      length: s.length,
+      maximumLength: CHECK_CHARACTER_WEIGHTS.length
+    }));
+  }
+  const checkCharacterPairSum = AI82_CREATOR.characterIndexes(s).reduce((accumulator, characterIndex, index) => {
+    if (characterIndex === void 0) {
+      throw new RangeError(`Invalid character '${s.charAt(index)}' at position ${index + 1}`);
+    }
+    return accumulator + characterIndex * CHECK_CHARACTER_WEIGHTS[weightIndexStart + index];
+  }, 0) % 1021;
+  const checkCharacterPairSumMod32 = checkCharacterPairSum % 32;
+  return CHECK_CHARACTERS[(checkCharacterPairSum - checkCharacterPairSumMod32) / 32] + CHECK_CHARACTERS[checkCharacterPairSumMod32];
+}
+function hasValidCheckCharacterPair(s) {
+  const checkCharacterPairIndex = s.length - 2;
+  return checkCharacterPair(s.substring(0, checkCharacterPairIndex)) === s.substring(checkCharacterPairIndex);
+}
+
+// src/idkey.ts
+var import_utility3 = require("@aidc-toolkit/utility");
+var import_ts_mixer = require("ts-mixer");
+var IdentificationKeyType = /* @__PURE__ */ ((IdentificationKeyType2) => {
+  IdentificationKeyType2["GTIN"] = "GTIN";
+  IdentificationKeyType2["GLN"] = "GLN";
+  IdentificationKeyType2["SSCC"] = "SSCC";
+  IdentificationKeyType2["GRAI"] = "GRAI";
+  IdentificationKeyType2["GIAI"] = "GIAI";
+  IdentificationKeyType2["GSRN"] = "GSRN";
+  IdentificationKeyType2["GDTI"] = "GDTI";
+  IdentificationKeyType2["GINC"] = "GINC";
+  IdentificationKeyType2["GSIN"] = "GSIN";
+  IdentificationKeyType2["GCN"] = "GCN";
+  IdentificationKeyType2["CPID"] = "CPID";
+  IdentificationKeyType2["GMN"] = "GMN";
+  return IdentificationKeyType2;
+})(IdentificationKeyType || {});
+var PrefixType = /* @__PURE__ */ ((PrefixType2) => {
+  PrefixType2[PrefixType2["GS1CompanyPrefix"] = 0] = "GS1CompanyPrefix";
+  PrefixType2[PrefixType2["UPCCompanyPrefix"] = 1] = "UPCCompanyPrefix";
+  PrefixType2[PrefixType2["GS18Prefix"] = 2] = "GS18Prefix";
+  return PrefixType2;
+})(PrefixType || {});
+var CharacterSet = /* @__PURE__ */ ((CharacterSet2) => {
+  CharacterSet2[CharacterSet2["Numeric"] = 0] = "Numeric";
+  CharacterSet2[CharacterSet2["AI82"] = 1] = "AI82";
+  CharacterSet2[CharacterSet2["AI39"] = 2] = "AI39";
+  return CharacterSet2;
+})(CharacterSet || {});
+var AbstractIdentificationKeyValidator = class _AbstractIdentificationKeyValidator {
+  static CHARACTER_SET_CREATORS = [
+    import_utility3.NUMERIC_CREATOR,
+    AI82_CREATOR,
+    AI39_CREATOR
+  ];
+  /**
+   * Identification key type.
+   */
+  _identificationKeyType;
+  /**
+   * Prefix type.
+   */
+  _prefixType;
+  /**
+   * Length.
+   */
+  _length;
+  /**
+   * Reference character set.
+   */
+  _referenceCharacterSet;
+  /**
+   * Reference creator.
+   */
+  _referenceCreator;
+  /**
+   * Get the character set creator for a character set.
+   *
+   * @param characterSet
+   * Character set.
+   *
+   * @returns
+   * Character set creator.
+   */
+  static creatorFor(characterSet) {
+    return _AbstractIdentificationKeyValidator.CHARACTER_SET_CREATORS[characterSet];
+  }
+  /**
+   * Constructor.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param prefixType
+   * Prefix type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param referenceCharacterSet
+   * Reference character set.
+   */
+  constructor(identificationKeyType, prefixType, length, referenceCharacterSet) {
+    this._identificationKeyType = identificationKeyType;
+    this._prefixType = prefixType;
+    this._length = length;
+    this._referenceCharacterSet = referenceCharacterSet;
+    this._referenceCreator = _AbstractIdentificationKeyValidator.creatorFor(referenceCharacterSet);
+  }
+  /**
+   * @inheritDoc
+   */
+  get identificationKeyType() {
+    return this._identificationKeyType;
+  }
+  /**
+   * @inheritDoc
+   */
+  get prefixType() {
+    return this._prefixType;
+  }
+  /**
+   * @inheritDoc
+   */
+  get length() {
+    return this._length;
+  }
+  /**
+   * @inheritDoc
+   */
+  get referenceCharacterSet() {
+    return this._referenceCharacterSet;
+  }
+  /**
+   * @inheritDoc
+   */
+  get referenceCreator() {
+    return this._referenceCreator;
+  }
+  /**
+   * Pad an identification key on the left with zero-value character for validation purposes. This is done to align an
+   * identification key with a position offset for any error message that may be thrown by the reference validator.
+   *
+   * @param identificationKey
+   * Identification key.
+   *
+   * @param validation
+   * Identification key validation parameters.
+   *
+   * @returns
+   * Padded identification key.
+   */
+  padIdentificationKey(identificationKey, validation) {
+    return validation?.positionOffset === void 0 ? identificationKey : this.referenceCreator.character(0).repeat(validation.positionOffset).concat(identificationKey);
+  }
+  /**
+   * Validate the prefix within an identification key.
+   *
+   * @param partialIdentificationKey
+   * Partial identification key.
+   *
+   * @param positionOffset
+   * Position offset within a larger string.
+   */
+  validatePrefix(partialIdentificationKey, positionOffset) {
+    PrefixManager.validatePrefix(this.prefixType, true, false, partialIdentificationKey, true, this.referenceCharacterSet === 0 /* Numeric */, positionOffset);
+  }
+};
+var LeaderType = /* @__PURE__ */ ((LeaderType2) => {
+  LeaderType2[LeaderType2["None"] = 0] = "None";
+  LeaderType2[LeaderType2["IndicatorDigit"] = 1] = "IndicatorDigit";
+  LeaderType2[LeaderType2["ExtensionDigit"] = 2] = "ExtensionDigit";
+  return LeaderType2;
+})(LeaderType || {});
+var AbstractNumericIdentificationKeyValidator = class extends AbstractIdentificationKeyValidator {
+  /**
+   * Leader type.
+   */
+  _leaderType;
+  /**
+   * Prefix position, determined by the leader type.
+   */
+  _prefixPosition;
+  /**
+   * Constructor.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param prefixType
+   * Prefix type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param leaderType
+   * Leader type.
+   */
+  constructor(identificationKeyType, prefixType, length, leaderType) {
+    super(identificationKeyType, prefixType, length, 0 /* Numeric */);
+    this._leaderType = leaderType;
+    this._prefixPosition = Number(this.leaderType === 2 /* ExtensionDigit */);
+  }
+  /**
+   * @inheritDoc
+   */
+  get leaderType() {
+    return this._leaderType;
+  }
+  /**
+   * @inheritDoc
+   */
+  validate(identificationKey, validation) {
+    if (this._prefixPosition === 0) {
+      super.validatePrefix(identificationKey, validation?.positionOffset);
+    } else {
+      super.validatePrefix(identificationKey.substring(this._prefixPosition), validation?.positionOffset === void 0 ? this._prefixPosition : validation.positionOffset + this._prefixPosition);
+    }
+    if (identificationKey.length !== this.length) {
+      throw new RangeError(i18n_default.t("IdentificationKey.identificationKeyTypeLength", {
+        ns: gs1NS,
+        identificationKeyType: this.identificationKeyType,
+        length: this.length
+      }));
+    }
+    if (!hasValidCheckDigit(this.padIdentificationKey(identificationKey, validation))) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidCheckDigit", {
+        ns: gs1NS
+      }));
+    }
+  }
+};
+var GTINType = /* @__PURE__ */ ((GTINType2) => {
+  GTINType2[GTINType2["GTIN13"] = 13] = "GTIN13";
+  GTINType2[GTINType2["GTIN12"] = 12] = "GTIN12";
+  GTINType2[GTINType2["GTIN8"] = 8] = "GTIN8";
+  GTINType2[GTINType2["GTIN14"] = 14] = "GTIN14";
+  return GTINType2;
+})(GTINType || {});
+var GTINLevel = /* @__PURE__ */ ((GTINLevel2) => {
+  GTINLevel2[GTINLevel2["Any"] = 0] = "Any";
+  GTINLevel2[GTINLevel2["RetailConsumer"] = 1] = "RetailConsumer";
+  GTINLevel2[GTINLevel2["OtherThanRetailConsumer"] = 2] = "OtherThanRetailConsumer";
+  return GTINLevel2;
+})(GTINLevel || {});
+var GTINValidator = class _GTINValidator extends AbstractNumericIdentificationKeyValidator {
+  /**
+   * Zero-suppressed GTIN-12 validation parameters.
+   */
+  static ZERO_SUPPRESSED_GTIN12_VALIDATION = {
+    minimumLength: 8,
+    maximumLength: 8
+  };
+  /**
+   * Constructor.
+   *
+   * @param gtinType
+   * GTIN type.
+   */
+  constructor(gtinType) {
+    let prefixType;
+    switch (gtinType) {
+      case 13 /* GTIN13 */:
+        prefixType = 0 /* GS1CompanyPrefix */;
+        break;
+      case 12 /* GTIN12 */:
+        prefixType = 1 /* UPCCompanyPrefix */;
+        break;
+      case 8 /* GTIN8 */:
+        prefixType = 2 /* GS18Prefix */;
+        break;
+      default:
+        throw new Error("Not supported");
+    }
+    super("GTIN" /* GTIN */, prefixType, gtinType, 1 /* IndicatorDigit */);
+  }
+  /**
+   * @inheritDoc
+   */
+  get gtinType() {
+    return this.length;
+  }
+  /**
+   * @inheritDoc
+   */
+  validatePrefix(partialIdentificationKey, positionOffset) {
+    PrefixManager.validatePrefix(this.prefixType, false, false, partialIdentificationKey, true, true, positionOffset);
+  }
+  /**
+   * Zero expand a zero-suppressed GTIN-12.
+   *
+   * @param zeroSuppressedGTIN12
+   * Zero-suppressed GTIN-12.
+   *
+   * @returns
+   * GTIN-12.
+   */
+  static zeroExpand(zeroSuppressedGTIN12) {
+    import_utility3.NUMERIC_CREATOR.validate(zeroSuppressedGTIN12, _GTINValidator.ZERO_SUPPRESSED_GTIN12_VALIDATION);
+    const d = Array.from(zeroSuppressedGTIN12);
+    let gtin12;
+    if (d[0] === "0") {
+      if (d[6] >= "5" && d[5] !== "0") {
+        gtin12 = `0${d[1]}${d[2]}${d[3]}${d[4]}${d[5]}0000${d[6]}${d[7]}`;
+      } else if (d[6] === "4" && d[4] !== "0") {
+        gtin12 = `0${d[1]}${d[2]}${d[3]}${d[4]}00000${d[5]}${d[7]}`;
+      } else if (d[6] <= "2") {
+        gtin12 = `0${d[1]}${d[2]}${d[6]}0000${d[3]}${d[4]}${d[5]}${d[7]}`;
+      } else if (d[6] === "3" && d[3] >= "3") {
+        gtin12 = `0${d[1]}${d[2]}${d[3]}00000${d[4]}${d[5]}${d[7]}`;
+      }
+    }
+    if (gtin12 === void 0) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidZeroSuppressedGTIN12", {
+        ns: gs1NS
+      }));
+    }
+    GTIN12_VALIDATOR.validate(gtin12);
+    return gtin12;
+  }
+  /**
+   * Validate any GTIN, optionally against a level.
+   *
+   * @param gtin
+   * GTIN.
+   *
+   * @param gtinLevel
+   * Level at which GTIN is to be validated.
+   */
+  static validateAny(gtin, gtinLevel = 0 /* Any */) {
+    let lengthValidatedGTIN = gtin;
+    let gtinLevelRestriction;
+    switch (gtin.length) {
+      case 13 /* GTIN13 */:
+        if (gtin.startsWith("0")) {
+          throw new RangeError(i18n_default.t("IdentificationKey.invalidGTIN13AtRetail", {
+            ns: gs1NS
+          }));
+        }
+        PrefixManager.validatePrefix(0 /* GS1CompanyPrefix */, false, false, gtin, true, true);
+        gtinLevelRestriction = 0 /* Any */;
+        break;
+      case 12 /* GTIN12 */:
+        PrefixManager.validatePrefix(1 /* UPCCompanyPrefix */, false, false, gtin, true, true);
+        gtinLevelRestriction = 0 /* Any */;
+        break;
+      case 8 /* GTIN8 */:
+        if (!gtin.startsWith("0")) {
+          PrefixManager.validatePrefix(2 /* GS18Prefix */, false, false, gtin, true, true);
+        } else {
+          lengthValidatedGTIN = _GTINValidator.zeroExpand(gtin);
+        }
+        gtinLevelRestriction = 1 /* RetailConsumer */;
+        break;
+      case 14 /* GTIN14 */:
+        PrefixManager.validatePrefix(0 /* GS1CompanyPrefix */, true, true, gtin.substring(1), true, true);
+        gtinLevelRestriction = 2 /* OtherThanRetailConsumer */;
+        break;
+      default:
+        throw new RangeError(i18n_default.t("IdentificationKey.invalidGTINLength", {
+          ns: gs1NS
+        }));
+    }
+    if (!hasValidCheckDigit(lengthValidatedGTIN)) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidCheckDigit", {
+        ns: gs1NS
+      }));
+    }
+    if (gtinLevel !== 0 /* Any */ && gtinLevelRestriction !== 0 /* Any */ && gtinLevelRestriction !== gtinLevel) {
+      throw new RangeError(i18n_default.t(gtinLevel === 1 /* RetailConsumer */ ? "IdentificationKey.invalidGTINAtRetail" : "IdentificationKey.invalidGTINAtOtherThanRetail", {
+        ns: gs1NS
+      }));
+    }
+  }
+  /**
+   * Validate a GTIN-14.
+   *
+   * @param gtin14
+   * GTIN-14.
+   */
+  static validateGTIN14(gtin14) {
+    if (gtin14.length !== 14 /* GTIN14 */) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidGTIN14Length", {
+        ns: gs1NS
+      }));
+    }
+    GTINCreator.validateAny(gtin14);
+  }
+};
+var NonGTINNumericIdentificationKeyValidator = class extends AbstractNumericIdentificationKeyValidator {
+  /**
+   * Constructor.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param leaderType
+   * Leader type.
+   */
+  constructor(identificationKeyType, length, leaderType = 0 /* None */) {
+    super(identificationKeyType, 0 /* GS1CompanyPrefix */, length, leaderType);
+  }
+};
+var SerializableNumericIdentificationKeyValidator = class _SerializableNumericIdentificationKeyValidator extends NonGTINNumericIdentificationKeyValidator {
+  /**
+   * Serial component length.
+   */
+  _serialComponentLength;
+  /**
+   * Serial component character set.
+   */
+  _serialComponentCharacterSet;
+  /**
+   * Serial component validation parameters.
+   */
+  _serialComponentValidation;
+  /**
+   * Serial component creator.
+   */
+  _serialComponentCreator;
+  /**
+   * Constructor.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param serialComponentLength
+   * Serial component length.
+   *
+   * @param serialComponentCharacterSet
+   * Serial component character set.
+   */
+  constructor(identificationKeyType, length, serialComponentLength, serialComponentCharacterSet) {
+    super(identificationKeyType, length, 0 /* None */);
+    this._serialComponentLength = serialComponentLength;
+    this._serialComponentCharacterSet = serialComponentCharacterSet;
+    this._serialComponentValidation = {
+      minimumLength: 1,
+      maximumLength: serialComponentLength,
+      component: () => i18n_default.t("IdentificationKey.serialComponent", {
+        ns: gs1NS
+      })
+    };
+    this._serialComponentCreator = _SerializableNumericIdentificationKeyValidator.creatorFor(serialComponentCharacterSet);
+  }
+  /**
+   * Get the serial component length.
+   */
+  get serialComponentLength() {
+    return this._serialComponentLength;
+  }
+  /**
+   * Get the serial component character set.
+   */
+  get serialComponentCharacterSet() {
+    return this._serialComponentCharacterSet;
+  }
+  /**
+   * Get the serial component validation parameters.
+   */
+  get serialComponentValidation() {
+    return this._serialComponentValidation;
+  }
+  /**
+   * Get the serial component creator.
+   */
+  get serialComponentCreator() {
+    return this._serialComponentCreator;
+  }
+  /**
+   * @inheritDoc
+   */
+  validate(identificationKey, validation) {
+    super.validate(identificationKey.substring(0, this.length), validation);
+    if (identificationKey.length > this.length) {
+      this.serialComponentCreator.validate(identificationKey.substring(this.length), this._serialComponentValidation);
+    }
+  }
+};
+var NonNumericIdentificationKeyValidator = class _NonNumericIdentificationKeyValidator extends AbstractIdentificationKeyValidator {
+  /**
+   * Validator to ensure that an identification key (minus check character pair) is not all numeric.
+   */
+  static NOT_ALL_NUMERIC_VALIDATOR = new class extends import_utility3.RegExpValidator {
+    /**
+     * @inheritDoc
+     */
+    createErrorMessage(_s) {
+      return i18n_default.t("IdentificationKey.referenceCantBeAllNumeric", {
+        ns: gs1NS
+      });
+    }
+  }(/\D/);
+  /**
+   * True if the identification key requires a check character pair.
+   */
+  _requiresCheckCharacterPair;
+  /**
+   * Constructor.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param referenceCharacterSet
+   * Reference character set.
+   *
+   * @param requiresCheckCharacterPair
+   * True if the identification key requires a check character pair.
+   */
+  constructor(identificationKeyType, length, referenceCharacterSet, requiresCheckCharacterPair = false) {
+    super(identificationKeyType, 0 /* GS1CompanyPrefix */, length, referenceCharacterSet);
+    this._requiresCheckCharacterPair = requiresCheckCharacterPair;
+  }
+  /**
+   * Determine if the identification key requires a check character pair.
+   */
+  get requiresCheckCharacterPair() {
+    return this._requiresCheckCharacterPair;
+  }
+  /**
+   * Validate a non-numeric identification key and throw an error if validation fails.
+   *
+   * @param identificationKey
+   * Identification key.
+   *
+   * @param validation
+   * Validation parameters.
+   */
+  validate(identificationKey, validation) {
+    const partialIdentificationKey = this.requiresCheckCharacterPair ? identificationKey.substring(0, identificationKey.length - 2) : identificationKey;
+    super.validatePrefix(partialIdentificationKey, validation?.positionOffset);
+    if (!this.requiresCheckCharacterPair) {
+      this.referenceCreator.validate(identificationKey, {
+        maximumLength: this.length,
+        positionOffset: validation?.positionOffset
+      });
+    } else if (!hasValidCheckCharacterPair(this.padIdentificationKey(identificationKey, validation))) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidCheckCharacterPair", {
+        ns: gs1NS
+      }));
+    }
+    if (validation?.exclusion === import_utility3.Exclusion.AllNumeric) {
+      _NonNumericIdentificationKeyValidator.NOT_ALL_NUMERIC_VALIDATOR.validate(partialIdentificationKey);
+    }
+  }
+};
+var GTIN13_VALIDATOR = new GTINValidator(13 /* GTIN13 */);
+var GTIN12_VALIDATOR = new GTINValidator(12 /* GTIN12 */);
+var GTIN8_VALIDATOR = new GTINValidator(8 /* GTIN8 */);
+var GTIN_VALIDATORS = [
+  GTIN13_VALIDATOR,
+  GTIN12_VALIDATOR,
+  GTIN8_VALIDATOR
+];
+var GLN_VALIDATOR = new NonGTINNumericIdentificationKeyValidator("GLN" /* GLN */, 13);
+var SSCC_VALIDATOR = new NonGTINNumericIdentificationKeyValidator("SSCC" /* SSCC */, 18, 2 /* ExtensionDigit */);
+var GRAI_VALIDATOR = new SerializableNumericIdentificationKeyValidator("GRAI" /* GRAI */, 13, 16, 1 /* AI82 */);
+var GIAI_VALIDATOR = new NonNumericIdentificationKeyValidator("GIAI" /* GIAI */, 30, 1 /* AI82 */);
+var GSRN_VALIDATOR = new NonGTINNumericIdentificationKeyValidator("GSRN" /* GSRN */, 18);
+var GDTI_VALIDATOR = new SerializableNumericIdentificationKeyValidator("GDTI" /* GDTI */, 13, 17, 1 /* AI82 */);
+var GINC_VALIDATOR = new NonNumericIdentificationKeyValidator("GINC" /* GINC */, 30, 1 /* AI82 */);
+var GSIN_VALIDATOR = new NonGTINNumericIdentificationKeyValidator("GSIN" /* GSIN */, 17);
+var GCN_VALIDATOR = new SerializableNumericIdentificationKeyValidator("GCN" /* GCN */, 13, 12, 0 /* Numeric */);
+var CPID_VALIDATOR = new NonNumericIdentificationKeyValidator("CPID" /* CPID */, 30, 2 /* AI39 */);
+var GMN_VALIDATOR = new NonNumericIdentificationKeyValidator("GMN" /* GMN */, 25, 1 /* AI82 */, true);
+var AbstractIdentificationKeyCreator = class {
+  /**
+   * Prefix manager.
+   */
+  _prefixManager;
+  /**
+   * Reference length.
+   */
+  _referenceLength;
+  /**
+   * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param prefix
+   * Prefix within prefix manager to use to calculate reference length.
+   *
+   * @param checkAllowance
+   * Number of characters to allow for check digit or check character pair.
+   */
+  init(prefixManager, prefix, checkAllowance) {
+    this._prefixManager = prefixManager;
+    this._referenceLength = this.length - prefix.length - checkAllowance;
+  }
+  /**
+   * @inheritDoc
+   */
+  get prefixManager() {
+    return this._prefixManager;
+  }
+  /**
+   * @inheritDoc
+   */
+  get prefix() {
+    return this.prefixManager.gs1CompanyPrefix;
+  }
+  /**
+   * @inheritDoc
+   */
+  get referenceLength() {
+    return this._referenceLength;
+  }
+};
+var AbstractNumericIdentificationKeyCreator = class _AbstractNumericIdentificationKeyCreator extends AbstractIdentificationKeyCreator {
+  /**
+   * Capacity.
+   */
+  _capacity;
+  /**
+   * Tweak for sparse creation.
+   */
+  _tweak = 0n;
+  /**
+   * Initialize the prefix manager. This method is in lieu of a constructor due to the mixin architecture.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param prefix
+   * Prefix within prefix manager to use to calculate reference length.
+   */
+  init(prefixManager, prefix) {
+    super.init(prefixManager, prefix, 1);
+    this._capacity = Number(import_utility3.CharacterSetCreator.powerOf10(this.referenceLength));
+  }
+  /**
+   * @inheritDoc
+   */
+  get capacity() {
+    return this._capacity;
+  }
+  /**
+   * Get the tweak for sparse creation.
+   */
+  get tweak() {
+    return this._tweak;
+  }
+  /**
+   * Set the tweak for sparse creation.
+   */
+  set tweak(value) {
+    this._tweak = value;
+  }
+  /**
+   * Build an identification key from a reference by merging it with the prefix and adding the check digit.
+   *
+   * @param reference
+   * Identification key reference.
+   *
+   * @returns
+   * Identification key.
+   */
+  buildIdentificationKey(reference) {
+    const partialIdentificationKey = this.leaderType === 2 /* ExtensionDigit */ ? reference.substring(0, 1) + this.prefix + reference.substring(1) : this.prefix + reference;
+    return partialIdentificationKey + checkDigit(partialIdentificationKey);
+  }
+  /**
+   * @inheritDoc
+   */
+  create(valueOrValues, sparse = false) {
+    return import_utility3.NUMERIC_CREATOR.create(this.referenceLength, valueOrValues, import_utility3.Exclusion.None, sparse ? this.tweak : void 0, (reference) => this.buildIdentificationKey(reference));
+  }
+  /**
+   * Create all identification keys from a partial identification key. Call is recursive until remaining reference
+   * length is 0.
+   *
+   * @param partialIdentificationKey
+   * Partial identification key. Initial value is `this.prefix`.
+   *
+   * @param remainingReferenceLength
+   * Remaining reference length. Initial value is `this.referenceLength`.
+   *
+   * @param extensionWeight
+   * If this value is not zero, the identification key has an extension digit, this call is setting it, and this value
+   * is applied to the calculation of the check digit.
+   *
+   * @param weight
+   * If the extension weight is zero, this value is applied to the calculation of the check digit.
+   *
+   * @param partialCheckDigitSum
+   * Partial check digit sum for the partial identification key.
+   *
+   * @yields
+   * Identification key.
+   */
+  static *createAllPartial(partialIdentificationKey, remainingReferenceLength, extensionWeight, weight, partialCheckDigitSum) {
+    if (remainingReferenceLength === 0) {
+      yield partialIdentificationKey + import_utility3.NUMERIC_CREATOR.character(9 - (partialCheckDigitSum + 9) % 10);
+    } else {
+      const nextRemainingReferenceLength = remainingReferenceLength - 1;
+      let nextPartialCheckDigitSum = partialCheckDigitSum;
+      if (extensionWeight !== 0) {
+        for (const c of import_utility3.NUMERIC_CREATOR.characterSet) {
+          yield* _AbstractNumericIdentificationKeyCreator.createAllPartial(c + partialIdentificationKey, nextRemainingReferenceLength, 0, weight, nextPartialCheckDigitSum);
+          nextPartialCheckDigitSum += extensionWeight;
+        }
+      } else {
+        const nextWeight = 4 - weight;
+        for (const c of import_utility3.NUMERIC_CREATOR.characterSet) {
+          yield* _AbstractNumericIdentificationKeyCreator.createAllPartial(partialIdentificationKey + c, nextRemainingReferenceLength, 0, nextWeight, nextPartialCheckDigitSum);
+          nextPartialCheckDigitSum += weight;
+        }
+      }
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  createAll() {
+    const hasExtensionDigit = this.leaderType === 2 /* ExtensionDigit */;
+    const prefix = this.prefix;
+    const referenceLength = this.referenceLength;
+    const startWeight = 3 - 2 * ((referenceLength + 1 - Number(hasExtensionDigit)) % 2);
+    return _AbstractNumericIdentificationKeyCreator.createAllPartial(prefix, referenceLength, hasExtensionDigit ? 3 - 2 * this.length % 2 : 0, startWeight, checkDigitSum(startWeight === 3, prefix));
+  }
+};
+var GTINCreator = class _GTINCreator extends (0, import_ts_mixer.Mixin)(GTINValidator, AbstractNumericIdentificationKeyCreator) {
+  /**
+   * Validation parameters for required indicator digit.
+   */
+  static REQUIRED_INDICATOR_DIGIT_VALIDATION = {
+    minimumLength: 1,
+    maximumLength: 1,
+    component: () => i18n_default.t("IdentificationKey.indicatorDigit", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Validation parameters for optional indicator digit.
+   */
+  static OPTIONAL_INDICATOR_DIGIT_VALIDATION = {
+    minimumLength: 0,
+    maximumLength: 1,
+    component: () => i18n_default.t("IdentificationKey.indicatorDigit", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Constructor. Called internally by {@link PrefixManager.gtinCreator}; should not be called by other code.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param gtinType
+   * GTIN type.
+   */
+  constructor(prefixManager, gtinType) {
+    super(gtinType);
+    this.init(prefixManager, prefixManager.prefix);
+  }
+  /**
+   * @inheritDoc
+   */
+  get prefix() {
+    return this.prefixManager.prefix;
+  }
+  /**
+   * Create GTIN-14(s) with an indicator digit and reference(s) based on numeric value(s). The value(s) is/are
+   * converted to reference(s) of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+   *
+   * @param indicatorDigit
+   * Indicator digit.
+   *
+   * @param valueOrValues
+   * Numeric value(s).
+   *
+   * @param sparse
+   * If true, the value(s) is/are mapped to a sparse sequence resistant to discovery. Default is false.
+   *
+   * @returns
+   * GTIN-14(s).
+   */
+  createGTIN14(indicatorDigit, valueOrValues, sparse = false) {
+    import_utility3.NUMERIC_CREATOR.validate(indicatorDigit, _GTINCreator.REQUIRED_INDICATOR_DIGIT_VALIDATION);
+    return import_utility3.NUMERIC_CREATOR.create(13 /* GTIN13 */ - this.prefixManager.gs1CompanyPrefix.length - 1, valueOrValues, import_utility3.Exclusion.None, sparse ? this.tweak : void 0, (reference) => {
+      const partialIdentificationKey = indicatorDigit + this.prefixManager.gs1CompanyPrefix + reference;
+      return partialIdentificationKey + checkDigit(partialIdentificationKey);
+    });
+  }
+  /**
+   * Zero suppress a GTIN-12.
+   *
+   * @param gtin12
+   * GTIN-12.
+   *
+   * @returns
+   * Zero-suppressed GTIN-12.
+   */
+  static zeroSuppress(gtin12) {
+    GTIN12_VALIDATOR.validate(gtin12);
+    const d = Array.from(gtin12);
+    let zeroSuppressedGTIN12;
+    if (d[0] === "0" && d[6] === "0" && d[7] === "0") {
+      if (d[10] >= "5" && d[8] === "0" && d[9] === "0" && d[5] !== "0") {
+        zeroSuppressedGTIN12 = `0${d[1]}${d[2]}${d[3]}${d[4]}${d[5]}${d[10]}${d[11]}`;
+      } else if (d[5] === "0" && d[8] === "0" && d[9] === "0" && d[4] !== "0") {
+        zeroSuppressedGTIN12 = `0${d[1]}${d[2]}${d[3]}${d[4]}${d[10]}4${d[11]}`;
+      } else if (d[3] <= "2" && d[4] === "0" && d[5] === "0") {
+        zeroSuppressedGTIN12 = `0${d[1]}${d[2]}${d[8]}${d[9]}${d[10]}${d[3]}${d[11]}`;
+      } else if (d[3] >= "3" && d[4] === "0" && d[5] === "0" && d[8] === "0") {
+        zeroSuppressedGTIN12 = `0${d[1]}${d[2]}${d[3]}${d[9]}${d[10]}3${d[11]}`;
+      }
+    }
+    if (zeroSuppressedGTIN12 === void 0) {
+      throw new RangeError(i18n_default.t("IdentificationKey.invalidZeroSuppressibleGTIN12", {
+        ns: gs1NS
+      }));
+    }
+    return zeroSuppressedGTIN12;
+  }
+  /**
+   * Convert a GTIN of any length to a GTIN-14 with an optional indicator digit.
+   *
+   * @param indicatorDigit
+   * Indicator digit. If blank, assumes "0" if the GTIN is not already a GTIN-14.
+   *
+   * @param gtin
+   * GTIN.
+   *
+   * @returns
+   * GTIN-14.
+   */
+  static convertToGTIN14(indicatorDigit, gtin) {
+    _GTINCreator.validateAny(gtin);
+    import_utility3.NUMERIC_CREATOR.validate(indicatorDigit, _GTINCreator.OPTIONAL_INDICATOR_DIGIT_VALIDATION);
+    const gtinLength = gtin.length;
+    let gtin14 = "0".repeat(14 /* GTIN14 */ - gtinLength) + gtin;
+    if (indicatorDigit.length !== 0 && indicatorDigit !== gtin14.charAt(0)) {
+      const partialGTIN14 = indicatorDigit + gtin14.substring(1, 14 /* GTIN14 */ - 1);
+      gtin14 = partialGTIN14 + checkDigit(partialGTIN14);
+    }
+    return gtin14;
+  }
+  /**
+   * Normalize a GTIN of any length.
+   * - A GTIN-14 that starts with six zeros or a GTIN-13 that starts with five zeros is normalized to GTIN-8.
+   * - A GTIN-14 that starts with two zeros or a GTIN-13 that starts with one zero is normalized to GTIN-12.
+   * - A GTIN-14 that starts with one zero is normalized to GTIN-13.
+   * - Otherwise, the GTIN is unchanged.
+   *
+   * @param gtin
+   * GTIN.
+   *
+   * @returns
+   * Normalized GTIN.
+   */
+  static normalize(gtin) {
+    const gtinLength = gtin.length;
+    let normalizedGTIN;
+    switch (gtinLength) {
+      case 13 /* GTIN13 */:
+        if (!gtin.startsWith("0")) {
+          normalizedGTIN = gtin;
+        } else if (!gtin.startsWith("00000")) {
+          normalizedGTIN = gtin.substring(1);
+        } else if (!gtin.startsWith("000000")) {
+          normalizedGTIN = gtin.substring(5);
+        } else {
+          throw new RangeError(i18n_default.t("IdentificationKey.invalidZeroSuppressedGTIN12AsGTIN13", {
+            ns: gs1NS
+          }));
+        }
+        break;
+      case 12 /* GTIN12 */:
+        normalizedGTIN = gtin;
+        break;
+      case 8 /* GTIN8 */:
+        if (!gtin.startsWith("0")) {
+          normalizedGTIN = gtin;
+        } else {
+          normalizedGTIN = _GTINCreator.zeroExpand(gtin);
+        }
+        break;
+      case 14 /* GTIN14 */:
+        if (!gtin.startsWith("0")) {
+          normalizedGTIN = gtin;
+        } else if (!gtin.startsWith("00")) {
+          normalizedGTIN = gtin.substring(1);
+        } else if (!gtin.startsWith("000000")) {
+          normalizedGTIN = gtin.substring(2);
+        } else if (!gtin.startsWith("0000000")) {
+          normalizedGTIN = gtin.substring(6);
+        } else {
+          throw new RangeError(i18n_default.t("IdentificationKey.invalidZeroSuppressedGTIN12AsGTIN14", {
+            ns: gs1NS
+          }));
+        }
+        break;
+      default:
+        throw new RangeError(i18n_default.t("IdentificationKey.invalidGTINLength", {
+          ns: gs1NS
+        }));
+    }
+    _GTINCreator.validateAny(normalizedGTIN);
+    return normalizedGTIN;
+  }
+};
+var NonGTINNumericIdentificationKeyCreator = class extends (0, import_ts_mixer.Mixin)(NonGTINNumericIdentificationKeyValidator, AbstractNumericIdentificationKeyCreator) {
+  /**
+   * Constructor. Called internally by {@link PrefixManager} non-GTIN numeric identification key creator getters;
+   * should not be called by other code.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param leaderType
+   * Leader type.
+   */
+  constructor(prefixManager, identificationKeyType, length, leaderType = 0 /* None */) {
+    super(identificationKeyType, length, leaderType);
+    this.init(prefixManager, prefixManager.gs1CompanyPrefix);
+  }
+};
+var SerializableNumericIdentificationKeyCreator = class extends (0, import_ts_mixer.Mixin)(SerializableNumericIdentificationKeyValidator, AbstractNumericIdentificationKeyCreator) {
+  /**
+   * Constructor. Called internally by {@link PrefixManager} serialized numeric identification key creator getters;
+   * should not be called by other code.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param serialComponentLength
+   * Serial component length.
+   *
+   * @param serialComponentCharacterSet
+   * Serial component character set.
+   */
+  constructor(prefixManager, identificationKeyType, length, serialComponentLength, serialComponentCharacterSet) {
+    super(identificationKeyType, length, serialComponentLength, serialComponentCharacterSet);
+    this.init(prefixManager, prefixManager.gs1CompanyPrefix);
+  }
+  /**
+   * Concatenate a validated base identification key with serial component(s).
+   *
+   * @param baseIdentificationKey
+   * Base identification key.
+   *
+   * @param serialComponentOrComponents
+   * Serial component(s).
+   *
+   * @returns
+   * Serialized identification key(s).
+   */
+  concatenateValidated(baseIdentificationKey, serialComponentOrComponents) {
+    let result;
+    const serialComponentCreator = this.serialComponentCreator;
+    const serialComponentValidation = this.serialComponentValidation;
+    function validateAndConcatenate(serialComponent) {
+      serialComponentCreator.validate(serialComponent, serialComponentValidation);
+      return baseIdentificationKey + serialComponent;
+    }
+    if (typeof serialComponentOrComponents !== "object") {
+      result = validateAndConcatenate(serialComponentOrComponents);
+    } else {
+      result = import_utility3.IteratorProxy.from(serialComponentOrComponents).map(validateAndConcatenate);
+    }
+    return result;
+  }
+  /**
+   * Create serialized identification key(s) with a reference based on a numeric value concatenated with serial
+   * component(s). The value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
+   *
+   * @param value
+   * Numeric value of the reference.
+   *
+   * @param serialComponentOrComponents
+   * Serial component(s).
+   *
+   * @param sparse
+   * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+   *
+   * @returns
+   * Serialized identification keys.
+   */
+  createSerialized(value, serialComponentOrComponents, sparse) {
+    return this.concatenateValidated(this.create(value, sparse), serialComponentOrComponents);
+  }
+  /**
+   * Concatenate a base identification key with serial component(s).
+   *
+   * @param baseIdentificationKey
+   * Base identification key.
+   *
+   * @param serialComponentOrComponents
+   * Serial component(s).
+   *
+   * @returns
+   * Serialized identification key(s).
+   */
+  concatenate(baseIdentificationKey, serialComponentOrComponents) {
+    this.validate(baseIdentificationKey);
+    return this.concatenateValidated(baseIdentificationKey, serialComponentOrComponents);
+  }
+};
+var NonNumericIdentificationKeyCreator = class extends (0, import_ts_mixer.Mixin)(NonNumericIdentificationKeyValidator, AbstractIdentificationKeyCreator) {
+  /**
+   * Reference validation parameters.
+   */
+  _referenceValidation;
+  /**
+   * Constructor. Called internally by {@link PrefixManager} non-numeric identification key creator getters; should
+   * not be called by other code.
+   *
+   * @param prefixManager
+   * Prefix manager.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param length
+   * Length.
+   *
+   * @param referenceCharacterSet
+   * Reference character set.
+   *
+   * @param requiresCheckCharacterPair
+   * True if the identification key requires a check character pair.
+   */
+  constructor(prefixManager, identificationKeyType, length, referenceCharacterSet, requiresCheckCharacterPair = false) {
+    super(identificationKeyType, length, referenceCharacterSet, requiresCheckCharacterPair);
+    this.init(prefixManager, prefixManager.gs1CompanyPrefix, 2 * Number(requiresCheckCharacterPair));
+    this._referenceValidation = {
+      minimumLength: 1,
+      // Maximum reference length has to account for prefix and check character pair.
+      maximumLength: this.referenceLength,
+      component: () => i18n_default.t("IdentificationKey.reference", {
+        ns: gs1NS
+      })
+    };
+  }
+  /**
+   * Get the reference validation parameters.
+   */
+  get referenceValidation() {
+    return this._referenceValidation;
+  }
+  /**
+   * Create identification key(s) with reference(s).
+   *
+   * @param referenceOrReferences
+   * Reference(s).
+   *
+   * @returns
+   * Identification key(s).
+   */
+  create(referenceOrReferences) {
+    let result;
+    const referenceCreator = this.referenceCreator;
+    const referenceValidation = this.referenceValidation;
+    const prefix = this.prefix;
+    const requiresCheckCharacterPair = this.requiresCheckCharacterPair;
+    function validateAndCreate(reference) {
+      referenceCreator.validate(reference, referenceValidation);
+      const partialIdentificationKey = prefix + reference;
+      return requiresCheckCharacterPair ? partialIdentificationKey + checkCharacterPair(partialIdentificationKey) : partialIdentificationKey;
+    }
+    if (typeof referenceOrReferences !== "object") {
+      result = validateAndCreate(referenceOrReferences);
+    } else {
+      result = import_utility3.IteratorProxy.from(referenceOrReferences).map(validateAndCreate);
+    }
+    return result;
+  }
+};
+var PrefixManager = class _PrefixManager {
+  /**
+   * Cached prefix managers, keyed by GS1 Company Prefix.
+   */
+  static PREFIX_MANAGERS_MAP = /* @__PURE__ */ new Map();
+  /**
+   * GS1 Company Prefix minimum length.
+   */
+  static GS1_COMPANY_PREFIX_MINIMUM_LENGTH = 4;
+  /**
+   * GS1 Company Prefix maximum length.
+   */
+  static GS1_COMPANY_PREFIX_MAXIMUM_LENGTH = 12;
+  /**
+   * U.P.C. Company Prefix minimum length.
+   */
+  static UPC_COMPANY_PREFIX_MINIMUM_LENGTH = 6;
+  /**
+   * U.P.C. Company Prefix maximum length.
+   */
+  static UPC_COMPANY_PREFIX_MAXIMUM_LENGTH = 11;
+  /**
+   * GS1-8 Prefix minimum length.
+   */
+  static GS1_8_PREFIX_MINIMUM_LENGTH = 2;
+  /**
+   * GS1-8 Prefix maximum length.
+   */
+  static GS1_8_PREFIX_MAXIMUM_LENGTH = 7;
+  /**
+   * Validation parameters for GS1 Company Prefix.
+   */
+  static GS1_COMPANY_PREFIX_VALIDATION = {
+    minimumLength: _PrefixManager.GS1_COMPANY_PREFIX_MINIMUM_LENGTH,
+    maximumLength: _PrefixManager.GS1_COMPANY_PREFIX_MAXIMUM_LENGTH,
+    component: () => i18n_default.t("Prefix.gs1CompanyPrefix", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Validation parameters for U.P.C. Company Prefix expressed as GS1 Company Prefix.
+   */
+  static UPC_COMPANY_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION = {
+    minimumLength: _PrefixManager.UPC_COMPANY_PREFIX_MINIMUM_LENGTH + 1,
+    maximumLength: _PrefixManager.UPC_COMPANY_PREFIX_MAXIMUM_LENGTH + 1,
+    component: () => i18n_default.t("Prefix.gs1CompanyPrefix", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Validation parameters for GS1-8 Prefix expressed as GS1 Company Prefix.
+   */
+  static GS1_8_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION = {
+    minimumLength: _PrefixManager.GS1_8_PREFIX_MINIMUM_LENGTH + 5,
+    maximumLength: _PrefixManager.GS1_8_PREFIX_MAXIMUM_LENGTH + 5,
+    component: () => i18n_default.t("Prefix.gs1CompanyPrefix", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Validation parameters for U.P.C. Company Prefix.
+   */
+  static UPC_COMPANY_PREFIX_VALIDATION = {
+    minimumLength: _PrefixManager.UPC_COMPANY_PREFIX_MINIMUM_LENGTH,
+    maximumLength: _PrefixManager.UPC_COMPANY_PREFIX_MAXIMUM_LENGTH,
+    component: () => i18n_default.t("Prefix.upcCompanyPrefix", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Validation parameters for GS1-8 Prefix.
+   */
+  static GS1_8_PREFIX_VALIDATION = {
+    minimumLength: _PrefixManager.GS1_8_PREFIX_MINIMUM_LENGTH,
+    maximumLength: _PrefixManager.GS1_8_PREFIX_MAXIMUM_LENGTH,
+    component: () => i18n_default.t("Prefix.gs18Prefix", {
+      ns: gs1NS
+    })
+  };
+  /**
+   * Creator tweak factors. Different numeric identification key types have different tweak factors so that sparse
+   * creation generates different sequences for each.
+   */
+  static CREATOR_TWEAK_FACTORS_MAP = /* @__PURE__ */ new Map([
+    ["GTIN" /* GTIN */, 1987n],
+    ["GLN" /* GLN */, 4241n],
+    ["SSCC" /* SSCC */, 8087n],
+    ["GRAI" /* GRAI */, 3221n],
+    ["GSRN" /* GSRN */, 2341n],
+    ["GDTI" /* GDTI */, 7333n],
+    ["GSIN" /* GSIN */, 5623n],
+    ["GCN" /* GCN */, 6869n]
+  ]);
+  /**
+   * Normalized prefix type.
+   */
+  _prefixType;
+  /**
+   * Normalized prefix.
+   */
+  _prefix;
+  /**
+   * Prefix as GS1 Company Prefix.
+   */
+  _gs1CompanyPrefix;
+  /**
+   * U.P.C. Company Prefix if prefix type is {@link PrefixType.UPCCompanyPrefix}.
+   */
+  _upcCompanyPrefix;
+  /**
+   * GS1-8 Prefix if prefix type is {@link PrefixType.GS18Prefix}.
+   */
+  _gs18Prefix;
+  /**
+   * Tweak factor.
+   */
+  _tweakFactor = 0n;
+  /**
+   * Cached identification key creators.
+   */
+  _identificationKeyCreatorsMap = /* @__PURE__ */ new Map();
+  /**
+   * Constructor.
+   *
+   * @param gs1CompanyPrefix
+   * GS1 Company Prefix.
+   */
+  constructor(gs1CompanyPrefix) {
+    this._gs1CompanyPrefix = gs1CompanyPrefix;
+    if (!gs1CompanyPrefix.startsWith("0")) {
+      this._prefixType = 0 /* GS1CompanyPrefix */;
+      this._prefix = this._gs1CompanyPrefix;
+    } else if (!gs1CompanyPrefix.startsWith("00000")) {
+      this._prefixType = 1 /* UPCCompanyPrefix */;
+      this._upcCompanyPrefix = gs1CompanyPrefix.substring(1);
+      this._prefix = this._upcCompanyPrefix;
+    } else {
+      this._prefixType = 2 /* GS18Prefix */;
+      this._gs18Prefix = gs1CompanyPrefix.substring(5);
+      this._prefix = this._gs18Prefix;
+    }
+    this.resetTweakFactor();
+  }
+  /**
+   * Get the prefix type.
+   */
+  get prefixType() {
+    return this._prefixType;
+  }
+  /**
+   * Get the prefix.
+   */
+  get prefix() {
+    return this._prefix;
+  }
+  /**
+   * Get the GS1 Company Prefix.
+   */
+  get gs1CompanyPrefix() {
+    return this._gs1CompanyPrefix;
+  }
+  /**
+   * Get the U.P.C. Company Prefix if prefix type is {@link PrefixType.UPCCompanyPrefix} or undefined if not.
+   */
+  get upcCompanyPrefix() {
+    return this._upcCompanyPrefix;
+  }
+  /**
+   * Get the GS1-8 Prefix if prefix type is {@link PrefixType.GS18Prefix} or undefined if not.
+   */
+  get gs18Prefix() {
+    return this._gs18Prefix;
+  }
+  /**
+   * Set the tweak for an identification key creator if it's a numeric identification key creator.
+   *
+   * @param creator
+   * Identification key creator.
+   */
+  setCreatorTweak(creator) {
+    const creatorTweakFactor = _PrefixManager.CREATOR_TWEAK_FACTORS_MAP.get(creator.identificationKeyType);
+    if (creatorTweakFactor !== void 0) {
+      creator.tweak = this.tweakFactor * creatorTweakFactor;
+    }
+  }
+  /**
+   * Get the tweak factor.
+   */
+  get tweakFactor() {
+    return this._tweakFactor;
+  }
+  /**
+   * Set the tweak factor.
+   *
+   * @param value
+   * Tweak factor.
+   */
+  set tweakFactor(value) {
+    const tweakFactor = BigInt(value);
+    if (this._tweakFactor !== tweakFactor) {
+      this._tweakFactor = tweakFactor;
+      for (const creator of this._identificationKeyCreatorsMap.values()) {
+        this.setCreatorTweak(creator);
+      }
+    }
+  }
+  /**
+   * Reset the tweak factor to its default (numeric value of the GS1 Company Prefix preceded by '1').
+   */
+  resetTweakFactor() {
+    this.tweakFactor = BigInt("1" + this.gs1CompanyPrefix);
+  }
+  /**
+   * Get a prefix manager.
+   *
+   * @param prefixType
+   * Prefix type.
+   *
+   * @param prefix
+   * Prefix.
+   *
+   * @returns
+   * Prefix manager with normalized prefix type and prefix.
+   */
+  static get(prefixType, prefix) {
+    _PrefixManager.validatePrefix(prefixType, true, true, prefix);
+    let gs1CompanyPrefix;
+    switch (prefixType) {
+      case 0 /* GS1CompanyPrefix */:
+        gs1CompanyPrefix = prefix;
+        break;
+      case 1 /* UPCCompanyPrefix */:
+        gs1CompanyPrefix = "0" + prefix;
+        break;
+      case 2 /* GS18Prefix */:
+        gs1CompanyPrefix = "00000" + prefix;
+        break;
+    }
+    let prefixManager = _PrefixManager.PREFIX_MANAGERS_MAP.get(gs1CompanyPrefix);
+    if (prefixManager === void 0) {
+      prefixManager = new _PrefixManager(gs1CompanyPrefix);
+      _PrefixManager.PREFIX_MANAGERS_MAP.set(gs1CompanyPrefix, prefixManager);
+    }
+    return prefixManager;
+  }
+  /**
+   * Validate a prefix.
+   *
+   * @param prefixType
+   * Prefix type.
+   *
+   * @param allowUPCCompanyPrefix
+   * If true, a U.P.C. Company Prefix expressed as a GS1 Company Prefix is permitted.
+   *
+   * @param allowGS18Prefix
+   * If true, a GS1-8 Prefix expressed as a GS1 Company Prefix is permitted.
+   *
+   * @param prefix
+   * Prefix.
+   *
+   * @param isFromIdentificationKey
+   * If true, the prefix is from an identification key and should be trimmed before its character set is validated.
+   *
+   * @param isNumericIdentificationKey
+   * If true, the prefix is from a numeric identification key and its character set will be validated by the caller.
+   *
+   * @param positionOffset
+   * Position offset within a larger string.
+   */
+  static validatePrefix(prefixType, allowUPCCompanyPrefix, allowGS18Prefix, prefix, isFromIdentificationKey = false, isNumericIdentificationKey = false, positionOffset) {
+    let baseValidation;
+    switch (prefixType) {
+      case 0 /* GS1CompanyPrefix */:
+        if (!prefix.startsWith("0")) {
+          baseValidation = _PrefixManager.GS1_COMPANY_PREFIX_VALIDATION;
+        } else if (!prefix.startsWith("00000")) {
+          if (!allowUPCCompanyPrefix) {
+            throw new RangeError(i18n_default.t("Prefix.gs1CompanyPrefixCantStartWith0", {
+              ns: gs1NS
+            }));
+          }
+          baseValidation = _PrefixManager.UPC_COMPANY_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+        } else if (!prefix.startsWith("000000")) {
+          if (!allowGS18Prefix) {
+            throw new RangeError(i18n_default.t("Prefix.gs1CompanyPrefixCantStartWith00000", {
+              ns: gs1NS
+            }));
+          }
+          baseValidation = _PrefixManager.GS1_8_PREFIX_AS_GS1_COMPANY_PREFIX_VALIDATION;
+        } else {
+          throw new RangeError(i18n_default.t("Prefix.gs1CompanyPrefixCantStartWith000000", {
+            ns: gs1NS
+          }));
+        }
+        break;
+      case 1 /* UPCCompanyPrefix */:
+        if (prefix.startsWith("0000")) {
+          throw new RangeError(i18n_default.t("Prefix.upcCompanyPrefixCantStartWith0000", {
+            ns: gs1NS
+          }));
+        }
+        baseValidation = _PrefixManager.UPC_COMPANY_PREFIX_VALIDATION;
+        break;
+      case 2 /* GS18Prefix */:
+        if (prefix.startsWith("0")) {
+          throw new RangeError(i18n_default.t("Prefix.gs18PrefixCantStartWith0", {
+            ns: gs1NS
+          }));
+        }
+        baseValidation = _PrefixManager.GS1_8_PREFIX_VALIDATION;
+        break;
+    }
+    const mergedValidation = {
+      ...baseValidation,
+      positionOffset
+    };
+    if (!isFromIdentificationKey) {
+      import_utility3.NUMERIC_CREATOR.validate(prefix, mergedValidation);
+    } else if (!isNumericIdentificationKey) {
+      import_utility3.NUMERIC_CREATOR.validate(prefix.substring(0, Math.min(mergedValidation.minimumLength, prefix.length - 1)), mergedValidation);
+    }
+  }
+  /**
+   * Get an identification key creator.
+   *
+   * @param identificationKeyType
+   * Identification key type.
+   *
+   * @param constructorCallback
+   * Constructor callback.
+   *
+   * @returns
+   * Identification key creator.
+   */
+  getIdentificationKeyCreator(identificationKeyType, constructorCallback) {
+    let creator = this._identificationKeyCreatorsMap.get(identificationKeyType);
+    if (creator === void 0) {
+      if (this.prefixType === 2 /* GS18Prefix */ && identificationKeyType !== "GTIN" /* GTIN */) {
+        throw new RangeError(i18n_default.t("Prefix.identificationKeyTypeNotSupportedByGS18Prefix", {
+          ns: gs1NS,
+          identificationKeyType
+        }));
+      }
+      creator = constructorCallback();
+      this.setCreatorTweak(creator);
+      this._identificationKeyCreatorsMap.set(identificationKeyType, creator);
+    }
+    return creator;
+  }
+  /**
+   * Get non-GTIN numeric identification key creator.
+   *
+   * @param validator
+   * Validator on which identification key creator is based.
+   *
+   * @returns
+   * Identification key creator.
+   */
+  getNonGTINNumericIdentificationKeyCreator(validator) {
+    return this.getIdentificationKeyCreator(validator.identificationKeyType, () => new NonGTINNumericIdentificationKeyCreator(this, validator.identificationKeyType, validator.length, validator.leaderType));
+  }
+  /**
+   * Get serialized numeric identification key creator.
+   *
+   * @param validator
+   * Validator on which identification key creator is based.
+   *
+   * @returns
+   * Identification key creator.
+   */
+  getSerializableNumericIdentificationKeyCreator(validator) {
+    return this.getIdentificationKeyCreator(validator.identificationKeyType, () => new SerializableNumericIdentificationKeyCreator(this, validator.identificationKeyType, validator.length, validator.serialComponentLength, validator.serialComponentCharacterSet));
+  }
+  /**
+   * Get non-numeric identification key creator.
+   *
+   * @param validator
+   * Validator on which identification key creator is based.
+   *
+   * @returns
+   * Identification key creator.
+   */
+  getNonNumericIdentificationKeyCreator(validator) {
+    return this.getIdentificationKeyCreator(validator.identificationKeyType, () => new NonNumericIdentificationKeyCreator(this, validator.identificationKeyType, validator.length, validator.referenceCharacterSet, validator.requiresCheckCharacterPair));
+  }
+  /**
+   * Get GTIN creator.
+   */
+  get gtinCreator() {
+    return this.getIdentificationKeyCreator("GTIN" /* GTIN */, () => {
+      let gtinType;
+      switch (this.prefixType) {
+        case 0 /* GS1CompanyPrefix */:
+          gtinType = 13 /* GTIN13 */;
+          break;
+        case 1 /* UPCCompanyPrefix */:
+          gtinType = 12 /* GTIN12 */;
+          break;
+        case 2 /* GS18Prefix */:
+          gtinType = 8 /* GTIN8 */;
+          break;
+      }
+      return new GTINCreator(this, gtinType);
+    });
+  }
+  /**
+   * Get GLN creator.
+   */
+  get glnCreator() {
+    return this.getNonGTINNumericIdentificationKeyCreator(GLN_VALIDATOR);
+  }
+  /**
+   * Get SSCC creator.
+   */
+  get ssccCreator() {
+    return this.getNonGTINNumericIdentificationKeyCreator(SSCC_VALIDATOR);
+  }
+  /**
+   * Get GRAI creator.
+   */
+  get graiCreator() {
+    return this.getSerializableNumericIdentificationKeyCreator(GRAI_VALIDATOR);
+  }
+  /**
+   * Get GIAI creator.
+   */
+  get giaiCreator() {
+    return this.getNonNumericIdentificationKeyCreator(GIAI_VALIDATOR);
+  }
+  /**
+   * Get GSRN creator.
+   */
+  get gsrnCreator() {
+    return this.getNonGTINNumericIdentificationKeyCreator(GSRN_VALIDATOR);
+  }
+  /**
+   * Get GDTI creator.
+   */
+  get gdtiCreator() {
+    return this.getSerializableNumericIdentificationKeyCreator(GDTI_VALIDATOR);
+  }
+  /**
+   * Get GINC creator.
+   */
+  get gincCreator() {
+    return this.getNonNumericIdentificationKeyCreator(GINC_VALIDATOR);
+  }
+  /**
+   * Get GSIN creator.
+   */
+  get gsinCreator() {
+    return this.getNonGTINNumericIdentificationKeyCreator(GSIN_VALIDATOR);
+  }
+  /**
+   * Get GCN creator.
+   */
+  get gcnCreator() {
+    return this.getSerializableNumericIdentificationKeyCreator(GCN_VALIDATOR);
+  }
+  /**
+   * Get CPID creator.
+   */
+  get cpidCreator() {
+    return this.getNonNumericIdentificationKeyCreator(CPID_VALIDATOR);
+  }
+  /**
+   * Get GMN creator.
+   */
+  get gmnCreator() {
+    return this.getNonNumericIdentificationKeyCreator(GMN_VALIDATOR);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AI39_CREATOR,
+  AI82_CREATOR,
+  CPID_VALIDATOR,
+  CharacterSet,
+  GCN_VALIDATOR,
+  GDTI_VALIDATOR,
+  GIAI_VALIDATOR,
+  GINC_VALIDATOR,
+  GLN_VALIDATOR,
+  GMN_VALIDATOR,
+  GRAI_VALIDATOR,
+  GSIN_VALIDATOR,
+  GSRN_VALIDATOR,
+  GTIN12_VALIDATOR,
+  GTIN13_VALIDATOR,
+  GTIN8_VALIDATOR,
+  GTINCreator,
+  GTINLevel,
+  GTINType,
+  GTINValidator,
+  GTIN_VALIDATORS,
+  IdentificationKeyType,
+  LeaderType,
+  NonGTINNumericIdentificationKeyCreator,
+  NonGTINNumericIdentificationKeyValidator,
+  NonNumericIdentificationKeyCreator,
+  NonNumericIdentificationKeyValidator,
+  PrefixManager,
+  PrefixType,
+  SSCC_VALIDATOR,
+  SerializableNumericIdentificationKeyCreator,
+  SerializableNumericIdentificationKeyValidator,
+  checkCharacterPair,
+  checkDigit,
+  checkDigitSum,
+  fiveDigitPriceWeightCheckDigit,
+  fourDigitPriceWeightCheckDigit,
+  hasValidCheckCharacterPair,
+  hasValidCheckDigit
+});