@aidc-toolkit/utility 0.9.3 → 0.9.5

package/dist/index.cjs

@@ -0,0 +1,1714 @@
+"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, {
+  ALPHABETIC_CREATOR: () => ALPHABETIC_CREATOR,
+  ALPHANUMERIC_CREATOR: () => ALPHANUMERIC_CREATOR,
+  CharacterSetCreator: () => CharacterSetCreator,
+  CharacterSetValidator: () => CharacterSetValidator,
+  EncryptionTransformer: () => EncryptionTransformer,
+  Exclusion: () => Exclusion,
+  HEXADECIMAL_CREATOR: () => HEXADECIMAL_CREATOR,
+  IdentityTransformer: () => IdentityTransformer,
+  IteratorProxy: () => IteratorProxy,
+  NUMERIC_CREATOR: () => NUMERIC_CREATOR,
+  RecordValidator: () => RecordValidator,
+  RegExpValidator: () => RegExpValidator,
+  Sequencer: () => Sequencer,
+  Transformer: () => Transformer
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/iterator_proxy.ts
+var IteratorProxyBase = class _IteratorProxyBase {
+  /**
+   * Convert an iteration source to an iterable.
+   *
+   * @param iterationSource
+   * Iteration source.
+   *
+   * @returns
+   * Iteration source if it is already an iterable, otherwise iteration source wrapped in an iterable.
+   */
+  static toIterable(iterationSource) {
+    return Symbol.iterator in iterationSource ? iterationSource : {
+      [Symbol.iterator]() {
+        return iterationSource;
+      }
+    };
+  }
+  /**
+   * Initial iterable.
+   */
+  _initialIterable;
+  /**
+   * Initial iterator.
+   */
+  _initialIterator;
+  /**
+   * Constructor.
+   *
+   * @param initialIterationSource
+   * Initial iteration source.
+   */
+  constructor(initialIterationSource) {
+    this._initialIterable = _IteratorProxyBase.toIterable(initialIterationSource);
+  }
+  /**
+   * Get the initial iterable.
+   */
+  get initialIterable() {
+    return this._initialIterable;
+  }
+  /**
+   * Get the initial iterator.
+   */
+  get initialIterator() {
+    if (this._initialIterator === void 0) {
+      this._initialIterator = this.initialIterable[Symbol.iterator]();
+    }
+    return this._initialIterator;
+  }
+  /**
+   * @inheritDoc
+   */
+  get [Symbol.toStringTag]() {
+    return "IteratorProxy";
+  }
+  /**
+   * @inheritDoc
+   */
+  [Symbol.dispose]() {
+  }
+  /**
+   * @inheritDoc
+   */
+  [Symbol.iterator]() {
+    return this;
+  }
+  /**
+   * Get the next result from the initial iterator.
+   *
+   * @param value
+   * Tuple value to be passed to Iterator.next().
+   *
+   * @returns
+   * Next result from the initial iterator.
+   */
+  initialNext(...value) {
+    return this.initialIterator.next(...value);
+  }
+  /**
+   * @inheritDoc
+   */
+  map(callback) {
+    return new IteratorMapProxy(this, callback);
+  }
+  /**
+   * @inheritDoc
+   */
+  flatMap(callback) {
+    return new IteratorFlatMapProxy(this, callback);
+  }
+  /**
+   * @inheritDoc
+   */
+  filter(predicate) {
+    return new IteratorFilterProxy(this, predicate, true);
+  }
+  /**
+   * @inheritDoc
+   */
+  take(limit) {
+    return new IteratorTakeProxy(this, limit);
+  }
+  /**
+   * @inheritDoc
+   */
+  drop(count) {
+    return new IteratorDropProxy(this, count);
+  }
+  /**
+   * @inheritDoc
+   */
+  reduce(callback, initialValue) {
+    let index = 0;
+    let result = initialValue;
+    for (const value of this) {
+      if (index === 0 && arguments.length === 1) {
+        result = value;
+      } else {
+        result = callback(result, value, index);
+      }
+      index++;
+    }
+    if (index === 0 && arguments.length === 1) {
+      throw new Error("reduce() of empty iterator with no initial value");
+    }
+    return result;
+  }
+  /**
+   * @inheritDoc
+   */
+  toArray() {
+    return Array.from(this);
+  }
+  /**
+   * @inheritDoc
+   */
+  forEach(callback) {
+    let index = 0;
+    for (const element of this) {
+      callback(element, index++);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  some(predicate) {
+    return new IteratorFilterProxy(this, predicate, true).next().done !== true;
+  }
+  /**
+   * @inheritDoc
+   */
+  every(predicate) {
+    return new IteratorFilterProxy(this, predicate, false).next().done === true;
+  }
+  /**
+   * @inheritDoc
+   */
+  find(predicate) {
+    return new IteratorFilterProxy(this, predicate, true).next().value;
+  }
+};
+var IteratorProxyObject = class extends IteratorProxyBase {
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    return this.initialNext(...value);
+  }
+};
+var IteratorMapProxyBase = class extends IteratorProxyBase {
+  /**
+   * Callback.
+   */
+  _callback;
+  /**
+   * Index into initial iteration source.
+   */
+  _index;
+  /**
+   * Constructor.
+   *
+   * @param initialIterationSource
+   * Initial iteration source.
+   *
+   * @param callback
+   * Callback.
+   */
+  constructor(initialIterationSource, callback) {
+    super(initialIterationSource);
+    this._callback = callback;
+    this._index = 0;
+  }
+  /**
+   * Get the next result from the intermediate iterator.
+   *
+   * @param value
+   * Tuple value to be passed to Iterator.next().
+   *
+   * @returns
+   * Next result from the intermediate iterator.
+   */
+  intermediateNext(...value) {
+    const initialResult = this.initialNext(...value);
+    return initialResult.done !== true ? {
+      value: this._callback(initialResult.value, this._index++)
+    } : {
+      done: true,
+      value: void 0
+    };
+  }
+};
+var IteratorMapProxy = class extends IteratorMapProxyBase {
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    return this.intermediateNext(...value);
+  }
+};
+var IteratorFlatMapProxy = class extends IteratorMapProxyBase {
+  _intermediateIterator;
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    let finalResult = void 0;
+    do {
+      if (this._intermediateIterator === void 0) {
+        const intermediateResult = this.intermediateNext(...value);
+        if (intermediateResult.done === true) {
+          finalResult = intermediateResult;
+        } else {
+          this._intermediateIterator = IteratorProxyBase.toIterable(intermediateResult.value)[Symbol.iterator]();
+        }
+      } else {
+        const pendingFinalResult = this._intermediateIterator.next();
+        if (pendingFinalResult.done === true) {
+          this._intermediateIterator = void 0;
+        } else {
+          finalResult = pendingFinalResult;
+        }
+      }
+    } while (finalResult === void 0);
+    return finalResult;
+  }
+};
+var IteratorFilterProxy = class extends IteratorProxyBase {
+  /**
+   * Predicate.
+   */
+  _predicate;
+  /**
+   * Expected truthy result of the predicate.
+   */
+  _expectedTruthy;
+  /**
+   * Index into iteration source.
+   */
+  _index;
+  /**
+   * Constructor.
+   *
+   * @param iterationSource
+   * Iteration source.
+   *
+   * @param predicate
+   * Predicate.
+   *
+   * @param expectedTruthy
+   * Expected truthy result of the predicate.
+   */
+  constructor(iterationSource, predicate, expectedTruthy) {
+    super(iterationSource);
+    this._predicate = predicate;
+    this._expectedTruthy = expectedTruthy;
+    this._index = 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    let result;
+    const expectedTruthy = this._expectedTruthy;
+    do {
+      result = this.initialNext(...value);
+    } while (result.done !== true && Boolean(this._predicate(result.value, this._index++)) !== expectedTruthy);
+    return result;
+  }
+};
+var IteratorCountProxyBase = class extends IteratorProxyObject {
+  /**
+   * Count.
+   */
+  _count;
+  /**
+   * Constructor.
+   *
+   * @param initialIterationSource
+   * Initial iteration source.
+   *
+   * @param count
+   * Count.
+   */
+  constructor(initialIterationSource, count) {
+    super(initialIterationSource);
+    if (!Number.isInteger(count) || count < 0) {
+      throw new RangeError("Count must be a positive integer");
+    }
+    this._count = count;
+  }
+  /**
+   * Determine if iterator is exhausted (by count or by iterator itself).
+   */
+  get exhausted() {
+    return this._count <= 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    const result = super.next(...value);
+    if (result.done !== true) {
+      this._count--;
+    } else {
+      this._count = 0;
+    }
+    return result;
+  }
+};
+var IteratorTakeProxy = class extends IteratorCountProxyBase {
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    return !this.exhausted ? super.next(...value) : {
+      done: true,
+      value: void 0
+    };
+  }
+};
+var IteratorDropProxy = class extends IteratorCountProxyBase {
+  /**
+   * @inheritDoc
+   */
+  next(...value) {
+    while (!this.exhausted) {
+      super.next(...value);
+    }
+    return super.next(...value);
+  }
+};
+function iteratorProxy() {
+  let supported;
+  try {
+    supported = process.env["NODE_ENV"] !== "test";
+  } catch (_e) {
+    supported = true;
+  }
+  if (supported) {
+    try {
+      Iterator.from([]);
+    } catch (_e) {
+      supported = false;
+    }
+  }
+  return supported ? Iterator : {
+    /**
+     * @inheritDoc
+     */
+    from(value) {
+      return value instanceof IteratorProxyBase ? value : new IteratorProxyObject(value);
+    }
+  };
+}
+var IteratorProxy = iteratorProxy();
+
+// src/sequencer.ts
+var Sequencer = class {
+  /**
+   * Start value (inclusive).
+   */
+  _startValue;
+  /**
+   * End value (exclusive).
+   */
+  _endValue;
+  /**
+   * Count of values.
+   */
+  _count;
+  /**
+   * Delta to the next value; equal to the sign of the count.
+   */
+  _nextDelta;
+  /**
+   * Minimum value (inclusive).
+   */
+  _minValue;
+  /**
+   * Maximum value (inclusive).
+   */
+  _maxValue;
+  /**
+   * Next value.
+   */
+  _nextValue;
+  /**
+   * Constructor.
+   *
+   * @param startValue
+   * Start value.
+   *
+   * @param count
+   * Count of values. If count is zero or positive, iteration ascends from start value, otherwise it descends from
+   * start value.
+   */
+  constructor(startValue, count) {
+    this._startValue = BigInt(startValue);
+    this._endValue = this._startValue + BigInt(count);
+    this._count = count;
+    const ascending = count >= 0;
+    if (ascending) {
+      this._nextDelta = 1n;
+      this._minValue = this._startValue;
+      this._maxValue = this._endValue - 1n;
+    } else {
+      this._nextDelta = -1n;
+      this._minValue = this._endValue + 1n;
+      this._maxValue = this._startValue;
+    }
+    this._nextValue = this._startValue;
+  }
+  /**
+   * Get the start value (inclusive).
+   */
+  get startValue() {
+    return this._startValue;
+  }
+  /**
+   * Get the end value (exclusive).
+   */
+  get endValue() {
+    return this._endValue;
+  }
+  /**
+   * Get the count of values.
+   */
+  get count() {
+    return this._count;
+  }
+  /**
+   * Get the minimum value (inclusive).
+   */
+  get minValue() {
+    return this._minValue;
+  }
+  /**
+   * Get the maximum value (inclusive).
+   */
+  get maxValue() {
+    return this._maxValue;
+  }
+  /**
+   * Iterable implementation.
+   *
+   * @returns
+   * this
+   */
+  [Symbol.iterator]() {
+    return this;
+  }
+  /**
+   * Iterator implementation.
+   *
+   * @returns
+   * Iterator result. If iterator is exhausted, the value is absolute value of the count.
+   */
+  next() {
+    const done = this._nextValue === this._endValue;
+    let result;
+    if (!done) {
+      result = {
+        value: this._nextValue
+      };
+      this._nextValue += this._nextDelta;
+    } else {
+      result = {
+        done: true,
+        value: Math.abs(this._count)
+      };
+    }
+    return result;
+  }
+  /**
+   * Reset the iterator.
+   */
+  reset() {
+    this._nextValue = this._startValue;
+  }
+};
+
+// src/locale/i18n.ts
+var import_core = require("@aidc-toolkit/core");
+
+// src/locale/en/locale_strings.ts
+var localeStrings = {
+  Transformer: {
+    domainMustBeGreaterThanZero: "Domain {{domain}} must be greater than 0",
+    tweakMustBeGreaterThanOrEqualToZero: "Tweak {{tweak}} must be greater than or equal to 0",
+    valueMustBeGreaterThanOrEqualToZero: "Value {{value}} must be greater than or equal to 0",
+    valueMustBeLessThan: "Value {{value}} must be less than {{domain}}",
+    minValueMustBeGreaterThanOrEqualToZero: "Minimum value {{minValue}} must be greater than or equal to 0",
+    maxValueMustBeLessThan: "Maximum value {{maxValue}} must be less than {{domain}}"
+  },
+  RegExpValidator: {
+    stringDoesNotMatchPattern: "String {{s}} does not match pattern"
+  },
+  CharacterSetValidator: {
+    firstZeroFirstCharacter: "Character set must support zero as first character",
+    allNumericAllNumericCharacters: "Character set must support all numeric characters in sequence",
+    stringMustNotBeAllNumeric: "String must not be all numeric",
+    lengthMustBeGreaterThanOrEqualTo: "Length {{length}} must be greater than or equal to {{minimumLength}}",
+    lengthMustBeLessThanOrEqualTo: "Length {{length}} must be less than or equal to {{maximumLength}}",
+    lengthMustBeEqualTo: "Length {{length}} must be equal to {{exactLength}}",
+    lengthOfComponentMustBeGreaterThanOrEqualTo: "Length {{length}} of {{component}} must be greater than or equal to {{minimumLength}}",
+    lengthOfComponentMustBeLessThanOrEqualTo: "Length {{length}} of {{component}} must be less than or equal to {{maximumLength}}",
+    lengthOfComponentMustBeEqualTo: "Length {{length}} of {{component}} must be equal to {{exactLength}}",
+    invalidCharacterAtPosition: "Invalid character '{{c}}' at position {{position}}",
+    invalidCharacterAtPositionOfComponent: "Invalid character '{{c}}' at position {{position}} of {{component}}",
+    exclusionNotSupported: "Exclusion value of {{exclusion}} is not supported",
+    invalidTweakWithAllNumericExclusion: "Tweak must not be used with all-numeric exclusion",
+    endSequenceValueMustBeLessThanOrEqualTo: "End sequence value (start sequence value + count - 1) must be less than {{domain}}"
+  },
+  RecordValidator: {
+    typeNameKeyNotFound: '{{typeName}} "{{key}}" not found'
+  }
+};
+
+// src/locale/fr/locale_strings.ts
+var localeStrings2 = {
+  Transformer: {
+    domainMustBeGreaterThanZero: "Le domaine {{domain}} doit \xEAtre sup\xE9rieur \xE0 0",
+    tweakMustBeGreaterThanOrEqualToZero: "Le r\xE9glage {{tweak}} doit \xEAtre sup\xE9rieur ou \xE9gal \xE0 0",
+    valueMustBeGreaterThanOrEqualToZero: "La valeur {{value}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 0",
+    valueMustBeLessThan: "La valeur {{value}} doit \xEAtre inf\xE9rieure \xE0 {{domain}}",
+    minValueMustBeGreaterThanOrEqualToZero: "La valeur minimale {{minValue}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 0",
+    maxValueMustBeLessThan: "La valeur maximale {{maxValue}} doit \xEAtre inf\xE9rieure \xE0 {{domain}}"
+  },
+  RegExpValidator: {
+    stringDoesNotMatchPattern: "La cha\xEEne {{s}} ne correspond pas au mod\xE8le"
+  },
+  CharacterSetValidator: {
+    firstZeroFirstCharacter: "Le jeu de caract\xE8res doit prendre en charge z\xE9ro comme premier caract\xE8re",
+    allNumericAllNumericCharacters: "Le jeu de caract\xE8res doit prendre en charge tous les caract\xE8res num\xE9riques en s\xE9quence",
+    stringMustNotBeAllNumeric: "La cha\xEEne ne doit pas \xEAtre enti\xE8rement num\xE9rique",
+    lengthMustBeGreaterThanOrEqualTo: "La longueur {{length}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 {{minimumLength}}",
+    lengthMustBeLessThanOrEqualTo: "La longueur {{length}} doit \xEAtre inf\xE9rieure ou \xE9gale \xE0 {{maximumLength}}",
+    lengthMustBeEqualTo: "La longueur {{length}} doit \xEAtre \xE9gale \xE0 {{exactLength}}",
+    lengthOfComponentMustBeGreaterThanOrEqualTo: "La longueur {{length}} de {{component}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 {{minimumLength}}",
+    lengthOfComponentMustBeLessThanOrEqualTo: "La longueur {{length}} de {{component}} doit \xEAtre inf\xE9rieure ou \xE9gale \xE0 {{maximumLength}}",
+    lengthOfComponentMustBeEqualTo: "La longueur {{length}} de {{component}} doit \xEAtre \xE9gale \xE0 {{exactLength}}",
+    invalidCharacterAtPosition: "Caract\xE8re non valide '{{c}}' \xE0 la position {{position}}",
+    invalidCharacterAtPositionOfComponent: "Caract\xE8re non valide '{{c}}' \xE0 la position {{position}} de {{component}}",
+    exclusionNotSupported: "La valeur d'exclusion de {{exclusion}} n'est pas prise en charge",
+    invalidTweakWithAllNumericExclusion: "Le r\xE9glage ne doit pas \xEAtre utilis\xE9 avec une exclusion enti\xE8rement num\xE9rique",
+    endSequenceValueMustBeLessThanOrEqualTo: "La valeur de la s\xE9quence de fin (valeur de la s\xE9quence de d\xE9but + nombre - 1) doit \xEAtre inf\xE9rieure \xE0 {{domaine}}"
+  },
+  RecordValidator: {
+    typeNameKeyNotFound: '{{typeName}} "{{key}}" introuvable'
+  }
+};
+
+// src/locale/i18n.ts
+var utilityNS = "aidct_utility";
+(0, import_core.i18nAssertValidResources)(localeStrings, "fr", localeStrings2);
+(0, import_core.i18nAddResourceBundle)("en", utilityNS, localeStrings);
+(0, import_core.i18nAddResourceBundle)("fr", utilityNS, localeStrings2);
+var i18n_default = import_core.i18next;
+
+// src/transformer.ts
+var Transformer = class _Transformer {
+  /**
+   * Transformers cache, mapping a domain to another map, which maps an optional tweak to a transformer.
+   */
+  static TRANSFORMER_MAPS_MAP = /* @__PURE__ */ new Map();
+  /**
+   * Domain.
+   */
+  _domain;
+  /**
+   * Constructor.
+   *
+   * @param domain
+   * Domain.
+   */
+  constructor(domain) {
+    this._domain = BigInt(domain);
+    if (this._domain <= 0n) {
+      throw new RangeError(i18n_default.t("Transformer.domainMustBeGreaterThanZero", {
+        ns: utilityNS,
+        domain
+      }));
+    }
+  }
+  /**
+   * Get a transformer, constructing it if necessary. The type returned is {@link IdentityTransformer} if tweak is
+   * undefined, {@link EncryptionTransformer} if tweak is defined. Note that although an {@link EncryptionTransformer}
+   * with a zero tweak operates as an {@link IdentityTransformer}, {@link EncryptionTransformer} is still the type
+   * returned if a zero tweak is explicitly specified.
+   *
+   * @param domain
+   * Domain.
+   *
+   * @param tweak
+   * Tweak.
+   *
+   * @returns
+   * {@link IdentityTransformer} if tweak is undefined, {@link EncryptionTransformer} if tweak is defined.
+   */
+  static get(domain, tweak) {
+    const domainN = BigInt(domain);
+    let transformersMap = _Transformer.TRANSFORMER_MAPS_MAP.get(domainN);
+    if (transformersMap === void 0) {
+      transformersMap = /* @__PURE__ */ new Map();
+      _Transformer.TRANSFORMER_MAPS_MAP.set(domainN, transformersMap);
+    }
+    const tweakN = tweak === void 0 ? void 0 : BigInt(tweak);
+    let transformer = transformersMap.get(tweakN);
+    if (transformer === void 0) {
+      transformer = tweakN === void 0 ? new IdentityTransformer(domainN) : new EncryptionTransformer(domainN, tweakN);
+      transformersMap.set(tweakN, transformer);
+    }
+    return transformer;
+  }
+  /**
+   * Get the domain.
+   */
+  get domain() {
+    return this._domain;
+  }
+  /**
+   * Validate that a value is within the domain.
+   *
+   * @param value
+   * Value.
+   */
+  validate(value) {
+    if (value < 0n) {
+      throw new RangeError(i18n_default.t("Transformer.valueMustBeGreaterThanOrEqualToZero", {
+        ns: utilityNS,
+        value
+      }));
+    }
+    if (value >= this.domain) {
+      throw new RangeError(i18n_default.t("Transformer.valueMustBeLessThan", {
+        ns: utilityNS,
+        value,
+        domain: this.domain
+      }));
+    }
+  }
+  /**
+   * Transform a value or values forward.
+   *
+   * @template T
+   * Type returned by transformation callback.
+   *
+   * @param valueOrValues
+   * Value(s).
+   *
+   * @param transformationCallback
+   * Called after value(s) is/are transformed to convert it/them to its/their final value(s).
+   *
+   * @returns
+   * Value(s) transformed into object(s).
+   */
+  forward(valueOrValues, transformationCallback) {
+    let result;
+    if (typeof valueOrValues !== "object") {
+      const valueN = BigInt(valueOrValues);
+      this.validate(valueN);
+      const transformedValue = this.doForward(valueN);
+      result = transformationCallback === void 0 ? transformedValue : transformationCallback(transformedValue, 0);
+    } else if (valueOrValues instanceof Sequencer) {
+      if (valueOrValues.minValue < 0n) {
+        throw new RangeError(i18n_default.t("Transformer.minValueMustBeGreaterThanOrEqualToZero", {
+          ns: utilityNS,
+          minValue: valueOrValues.minValue
+        }));
+      }
+      if (valueOrValues.maxValue >= this.domain) {
+        throw new RangeError(i18n_default.t("Transformer.maxValueMustBeLessThan", {
+          ns: utilityNS,
+          maxValue: valueOrValues.maxValue,
+          domain: this.domain
+        }));
+      }
+      result = transformationCallback === void 0 ? IteratorProxy.from(valueOrValues).map((value) => this.doForward(value)) : IteratorProxy.from(valueOrValues).map((value, index) => transformationCallback(this.doForward(value), index));
+    } else {
+      result = transformationCallback === void 0 ? IteratorProxy.from(valueOrValues).map((value) => {
+        const valueN = BigInt(value);
+        this.validate(valueN);
+        return this.doForward(valueN);
+      }) : IteratorProxy.from(valueOrValues).map((value, index) => {
+        const valueN = BigInt(value);
+        this.validate(valueN);
+        return transformationCallback(this.doForward(valueN), index);
+      });
+    }
+    return result;
+  }
+  /**
+   * Transform a value in reverse.
+   *
+   * @param transformedValue
+   * Transformed value.
+   *
+   * @returns
+   * Value.
+   */
+  reverse(transformedValue) {
+    const transformedValueN = BigInt(transformedValue);
+    this.validate(transformedValueN);
+    return this.doReverse(transformedValueN);
+  }
+};
+var IdentityTransformer = class extends Transformer {
+  /**
+   * @inheritDoc
+   */
+  doForward(value) {
+    return value;
+  }
+  /**
+   * @inheritDoc
+   */
+  doReverse(transformedValue) {
+    return transformedValue;
+  }
+};
+var EncryptionTransformer = class _EncryptionTransformer extends Transformer {
+  /**
+   * Individual bits, pre-calculated for performance.
+   */
+  static BITS = new Uint8Array([
+    1,
+    2,
+    4,
+    8,
+    16,
+    32,
+    64,
+    128
+  ]);
+  /**
+   * Inverse individual bits, pre-calculated for performance.
+   */
+  static INVERSE_BITS = new Uint8Array([
+    254,
+    253,
+    251,
+    247,
+    239,
+    223,
+    191,
+    127
+  ]);
+  /**
+   * Number of bytes covered by the domain.
+   */
+  _domainBytes;
+  /**
+   * Tweak.
+   */
+  _tweak;
+  /**
+   * Xor bytes array generated from the domain and tweak.
+   */
+  _xorBytes;
+  /**
+   * Bits array generated from the domain and tweak.
+   */
+  _bits;
+  /**
+   * Inverse bits array generated from the domain and tweak.
+   */
+  _inverseBits;
+  /**
+   * Number of rounds (length of arrays) generated from the domain and tweak.
+   */
+  _rounds;
+  /**
+   * Constructor.
+   *
+   * @param domain
+   * Domain.
+   *
+   * @param tweak
+   * Tweak.
+   */
+  constructor(domain, tweak) {
+    super(domain);
+    if (tweak < 0n) {
+      throw new RangeError(i18n_default.t("Transformer.tweakMustBeGreaterThanOrEqualToZero", {
+        ns: utilityNS,
+        tweak
+      }));
+    }
+    let domainBytes = 0;
+    for (let reducedDomainMinusOne = this.domain - 1n; reducedDomainMinusOne !== 0n; reducedDomainMinusOne = reducedDomainMinusOne >> 8n) {
+      domainBytes++;
+    }
+    this._domainBytes = domainBytes;
+    this._tweak = BigInt(tweak);
+    const xorBytes = new Array();
+    const bits = new Array();
+    const inverseBits = new Array();
+    for (let reducedKey = this.domain * this.tweak * 603868999n; reducedKey !== 0n; reducedKey = reducedKey >> 8n) {
+      const keyByte = Number(reducedKey & 0xFFn);
+      xorBytes.unshift(keyByte);
+      const bitNumber = keyByte & 7;
+      bits.push(_EncryptionTransformer.BITS[bitNumber]);
+      inverseBits.push(_EncryptionTransformer.INVERSE_BITS[bitNumber]);
+    }
+    if (domainBytes === 1) {
+      const domainMask = _EncryptionTransformer.BITS.filter((bit) => bit < domain).reduce((accumulator, bit) => accumulator | bit, 0);
+      this._xorBytes = new Uint8Array([xorBytes.reduce((accumulator, xorByte) => accumulator ^ xorByte, 0) & domainMask]);
+      this._bits = new Uint8Array([_EncryptionTransformer.BITS[0]]);
+      this._inverseBits = new Uint8Array([_EncryptionTransformer.INVERSE_BITS[0]]);
+      this._rounds = 1;
+    } else {
+      this._xorBytes = new Uint8Array(xorBytes);
+      this._bits = new Uint8Array(bits);
+      this._inverseBits = new Uint8Array(inverseBits);
+      this._rounds = xorBytes.length;
+    }
+  }
+  /**
+   * Get the tweak.
+   */
+  get tweak() {
+    return this._tweak;
+  }
+  /**
+   * Convert a value to a byte array big enough to handle the entire domain.
+   *
+   * @param value
+   * Value.
+   *
+   * @returns
+   * Big-endian byte array equivalent to the value.
+   */
+  valueToBytes(value) {
+    const bytes = new Uint8Array(this._domainBytes);
+    let reducedValue = value;
+    for (let index = this._domainBytes - 1; index >= 0; index--) {
+      bytes[index] = Number(reducedValue & 0xFFn);
+      reducedValue = reducedValue >> 8n;
+    }
+    return bytes;
+  }
+  /**
+   * Convert a byte array to a value.
+   *
+   * @param bytes
+   * Big-endian byte array equivalent to the value.
+   *
+   * @returns
+   * Value.
+   */
+  static bytesToValue(bytes) {
+    return bytes.reduce((accumulator, byte) => accumulator << 8n | BigInt(byte), 0n);
+  }
+  /**
+   * Shuffle a byte array.
+   *
+   * The input array to the forward operation (output from the reverse operation) is `bytes` and the output array from
+   * the forward operation (input to the reverse operation) is `bytes'`.
+   *
+   * The shuffle operation starts by testing the bit at `bits[round]` for each `byte` in `bytes`. The indexes for all
+   * bytes with that bit set are put into one array (`shuffleIndexes1`) and the rest are put into another
+   * (`shuffleIndexes0`). The two arrays are concatenated and used to shuffle the input array, using their values
+   * (`shuffleIndex`) and the indexes of those values (`index`) in the concatenated array.
+   *
+   * Forward shuffling moves the entry at `shuffleIndex` to the `index` position.
+   *
+   * Reverse shuffling moves the entry at `index` to the `shuffleIndex` position.
+   *
+   * As each byte is moved, the bit at `bits[round]` is preserved in its original position. This ensures that the
+   * process is reversible.
+   *
+   * @param bytes
+   * Byte array.
+   *
+   * @param round
+   * Round number.
+   *
+   * @param forward
+   * True if operating forward (encrypting), false if operating in reverse (decrypting).
+   *
+   * @returns
+   * Shuffled byte array.
+   */
+  shuffle(bytes, round, forward) {
+    const bytesLength = bytes.length;
+    const determinants = new Uint8Array(bytesLength);
+    const shuffleIndexes1 = new Array();
+    const shuffleIndexes0 = new Array();
+    const bit = this._bits[round];
+    bytes.forEach((byte, index) => {
+      const determinant = byte & bit;
+      determinants[index] = determinant;
+      (determinant !== 0 ? shuffleIndexes1 : shuffleIndexes0).push(index);
+    });
+    const inverseBit = this._inverseBits[round];
+    const shuffleBytes = new Uint8Array(bytesLength);
+    [...shuffleIndexes1, ...shuffleIndexes0].forEach((shuffleIndex, index) => {
+      if (forward) {
+        shuffleBytes[index] = bytes[shuffleIndex] & inverseBit | determinants[index];
+      } else {
+        shuffleBytes[shuffleIndex] = bytes[index] & inverseBit | determinants[shuffleIndex];
+      }
+    });
+    return shuffleBytes;
+  }
+  /**
+   * Xor a byte array.
+   *
+   * The input array to the forward operation (output from the reverse operation) is `bytes` and the output array from
+   * the forward operation (input to the reverse operation) is `bytes'`.
+   *
+   * Forward:
+   * - `bytes'[0] = bytes[0] ^ xorBytes[round]`
+   * - `bytes'[1] = bytes[1] ^ bytes'[0]`
+   * - `bytes'[2] = bytes[2] ^ bytes'[1]`
+   * - `...`
+   * - `bytes'[domainBytes - 1] = bytes[domainBytes - 1] ^ bytes'[domainBytes - 2]`
+   *
+   * Reverse:
+   * - `bytes[0] = bytes'[0] ^ xorBytes[round]`
+   * - `bytes[1] = bytes'[1] ^ bytes'[0]`
+   * - `bytes[2] = bytes'[2] ^ bytes'[1]`
+   * - `...`
+   * - `bytes[domainBytes - 1] = bytes'[domainBytes - 1] ^ bytes'[domainBytes - 2]`
+   *
+   * @param bytes
+   * Byte array.
+   *
+   * @param round
+   * Round number.
+   *
+   * @param forward
+   * True if operating forward (encrypting), false if operating in reverse (decrypting).
+   *
+   * @returns
+   * Xored byte array.
+   */
+  xor(bytes, round, forward) {
+    let cumulativeXorByte = this._xorBytes[round];
+    return bytes.map((byte) => {
+      const xorByte = byte ^ cumulativeXorByte;
+      cumulativeXorByte = forward ? xorByte : byte;
+      return xorByte;
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  doForward(value) {
+    let bytes = this.valueToBytes(value);
+    let transformedValue;
+    do {
+      for (let round = 0; round < this._rounds; round++) {
+        bytes = this.xor(this.shuffle(bytes, round, true), round, true);
+      }
+      transformedValue = _EncryptionTransformer.bytesToValue(bytes);
+    } while (transformedValue >= this.domain);
+    return transformedValue;
+  }
+  /**
+   * @inheritDoc
+   */
+  doReverse(transformedValue) {
+    let bytes = this.valueToBytes(transformedValue);
+    let value;
+    do {
+      for (let round = this._rounds - 1; round >= 0; round--) {
+        bytes = this.shuffle(this.xor(bytes, round, false), round, false);
+      }
+      value = _EncryptionTransformer.bytesToValue(bytes);
+    } while (value >= this.domain);
+    return value;
+  }
+};
+
+// src/reg_exp.ts
+var RegExpValidator = class {
+  /**
+   * Regular expression.
+   */
+  _regExp;
+  /**
+   * Constructor.
+   *
+   * @param regExp
+   * Regular expression. See {@link RegExpValidator | class documentation} for notes.
+   */
+  constructor(regExp) {
+    this._regExp = regExp;
+  }
+  /**
+   * Get the regular expression.
+   */
+  get regExp() {
+    return this._regExp;
+  }
+  /**
+   * Create an error message for a string. The generic error message is sufficient for many use cases but a more
+   * domain-specific error message, possibly including the pattern itself, is often required.
+   *
+   * @param s
+   * String.
+   *
+   * @returns
+   * Error message.
+   */
+  createErrorMessage(s) {
+    return i18n_default.t("RegExpValidator.stringDoesNotMatchPattern", {
+      ns: utilityNS,
+      s
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  validate(s) {
+    if (!this._regExp.test(s)) {
+      throw new RangeError(this.createErrorMessage(s));
+    }
+  }
+};
+
+// src/record.ts
+var RecordValidator = class {
+  /**
+   * Type name for error message.
+   */
+  _typeName;
+  /**
+   * Record in which to look up keys.
+   */
+  _record;
+  /**
+   * Constructor.
+   *
+   * @param typeName
+   * Type name for error message.
+   *
+   * @param record
+   * Record in which to look up keys.
+   */
+  constructor(typeName, record) {
+    this._typeName = typeName;
+    this._record = record;
+  }
+  /**
+   * Get the type name.
+   */
+  get typeName() {
+    return this._typeName;
+  }
+  /**
+   * Get the record.
+   */
+  get record() {
+    return this._record;
+  }
+  /**
+   * Validate a key by looking it up in the record.
+   *
+   * @param key
+   * Record key.
+   */
+  validate(key) {
+    if (this.record[key] === void 0) {
+      throw new RangeError(i18n_default.t("RecordValidator.typeNameKeyNotFound", {
+        ns: utilityNS,
+        typeName: this.typeName,
+        key
+      }));
+    }
+  }
+};
+
+// src/character_set.ts
+var Exclusion = /* @__PURE__ */ ((Exclusion2) => {
+  Exclusion2[Exclusion2["None"] = 0] = "None";
+  Exclusion2[Exclusion2["FirstZero"] = 1] = "FirstZero";
+  Exclusion2[Exclusion2["AllNumeric"] = 2] = "AllNumeric";
+  return Exclusion2;
+})(Exclusion || {});
+var CharacterSetValidator = class _CharacterSetValidator {
+  static NOT_ALL_NUMERIC_VALIDATOR = new class extends RegExpValidator {
+    /**
+     * Create an error message for an all-numeric string.
+     *
+     * @param _s
+     * String.
+     *
+     * @returns
+     * Error message.
+     */
+    createErrorMessage(_s) {
+      return i18n_default.t("CharacterSetValidator.stringMustNotBeAllNumeric", {
+        ns: utilityNS
+      });
+    }
+  }(/\D/);
+  /**
+   * Character set.
+   */
+  _characterSet;
+  /**
+   * Character set map, mapping each character in the character set to its index such that
+   * `_characterSetMap.get(_characterSet[index]) === index`.
+   */
+  _characterSetMap;
+  /**
+   * Exclusions supported by the character set.
+   */
+  _exclusionSupport;
+  /**
+   * Constructor.
+   *
+   * @param characterSet
+   * Character set. Each element is a single-character string, unique within the array, that defines the character
+   * set.
+   *
+   * @param exclusionSupport
+   * Exclusions supported by the character set. All character sets implicitly support {@link Exclusion.None}.
+   */
+  constructor(characterSet, ...exclusionSupport) {
+    this._characterSet = characterSet;
+    const characterSetMap = /* @__PURE__ */ new Map();
+    characterSet.forEach((c, index) => {
+      characterSetMap.set(c, index);
+    });
+    this._characterSetMap = characterSetMap;
+    this._exclusionSupport = exclusionSupport;
+  }
+  /**
+   * Get the character set.
+   */
+  get characterSet() {
+    return this._characterSet;
+  }
+  /**
+   * Get the character set size.
+   */
+  get characterSetSize() {
+    return this._characterSet.length;
+  }
+  /**
+   * Get the exclusions supported by the character set.
+   */
+  get exclusionSupport() {
+    return this._exclusionSupport;
+  }
+  /**
+   * Get the character at an index.
+   *
+   * @param index
+   * Index into the character set.
+   *
+   * @returns
+   * Character at the index.
+   */
+  character(index) {
+    return this._characterSet[index];
+  }
+  /**
+   * Get the index for a character.
+   *
+   * @param c
+   * Character.
+   *
+   * @returns
+   * Index for the character or undefined if the character is not in the character set.
+   */
+  characterIndex(c) {
+    return this._characterSetMap.get(c);
+  }
+  /**
+   * Get the indexes for all characters in a string.
+   *
+   * @param s
+   * String.
+   *
+   * @returns
+   * Array of indexes for each character or undefined if the character is not in the character set.
+   */
+  characterIndexes(s) {
+    return [...s].map((c) => this._characterSetMap.get(c));
+  }
+  /**
+   * Convert a component definition to a string or undefined. Checks the type of the component and makes the callback
+   * if required.
+   *
+   * @param component
+   * Component definition as a string, callback, or undefined.
+   *
+   * @returns
+   * Component as a string or undefined.
+   */
+  static componentToString(component) {
+    return typeof component === "function" ? component() : component;
+  }
+  /**
+   * Validate that an exclusion is supported. If not, an error is thrown.
+   *
+   * @param exclusion
+   * Exclusion.
+   */
+  validateExclusion(exclusion) {
+    if (exclusion !== 0 /* None */ && !this._exclusionSupport.includes(exclusion)) {
+      throw new RangeError(i18n_default.t("CharacterSetValidator.exclusionNotSupported", {
+        ns: utilityNS,
+        exclusion
+      }));
+    }
+  }
+  /**
+   * Validate a string. If the string violates the character set or any of the character set validation parameters, an
+   * error is thrown.
+   *
+   * @param s
+   * String.
+   *
+   * @param validation
+   * Character set validation parameters.
+   */
+  validate(s, validation) {
+    const length = s.length;
+    const minimumLength = validation?.minimumLength;
+    const maximumLength = validation?.maximumLength;
+    if (minimumLength !== void 0 && length < minimumLength) {
+      let errorMessage;
+      if (maximumLength !== void 0 && maximumLength === minimumLength) {
+        errorMessage = i18n_default.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeEqualTo", {
+          ns: utilityNS,
+          component: _CharacterSetValidator.componentToString(validation?.component),
+          length,
+          exactLength: minimumLength
+        });
+      } else {
+        errorMessage = i18n_default.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeGreaterThanOrEqualTo", {
+          ns: utilityNS,
+          component: _CharacterSetValidator.componentToString(validation?.component),
+          length,
+          minimumLength
+        });
+      }
+      throw new RangeError(errorMessage);
+    }
+    if (maximumLength !== void 0 && length > maximumLength) {
+      throw new RangeError(i18n_default.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeLessThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeLessThanOrEqualTo", {
+        ns: utilityNS,
+        component: _CharacterSetValidator.componentToString(validation?.component),
+        length,
+        maximumLength
+      }));
+    }
+    const index = this.characterIndexes(s).findIndex((characterIndex) => characterIndex === void 0);
+    if (index !== -1) {
+      throw new RangeError(i18n_default.t(validation?.component === void 0 ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
+        ns: utilityNS,
+        component: _CharacterSetValidator.componentToString(validation?.component),
+        c: s.charAt(index),
+        position: index + (validation?.positionOffset ?? 0) + 1
+      }));
+    }
+    if (validation?.exclusion !== void 0) {
+      this.validateExclusion(validation.exclusion);
+      switch (validation.exclusion) {
+        case 0 /* None */:
+          break;
+        case 1 /* FirstZero */:
+          if (s.startsWith("0")) {
+            throw new RangeError(i18n_default.t(validation.component === void 0 ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
+              ns: utilityNS,
+              component: _CharacterSetValidator.componentToString(validation.component),
+              c: "0",
+              position: (validation.positionOffset ?? 0) + 1
+            }));
+          }
+          break;
+        case 2 /* AllNumeric */:
+          _CharacterSetValidator.NOT_ALL_NUMERIC_VALIDATOR.validate(s);
+          break;
+      }
+    }
+  }
+};
+var CharacterSetCreator = class _CharacterSetCreator extends CharacterSetValidator {
+  /**
+   * Maximum string length supported.
+   */
+  static MAXIMUM_STRING_LENGTH = 40;
+  /**
+   * Powers of 10 from 1 (`10**0`) to `10**MAXIMUM_STRING_LENGTH`.
+   */
+  static _powersOf10 = _CharacterSetCreator.createPowersOf(10);
+  /**
+   * Create powers of a given base from 1 (`base**0`) to `base**MAXIMUM_STRING_LENGTH`.
+   *
+   * @param base
+   * Number base.
+   *
+   * @returns
+   * Array of powers of base.
+   */
+  static createPowersOf(base) {
+    const powersOf = new Array(this.MAXIMUM_STRING_LENGTH + 1);
+    const baseN = BigInt(base);
+    for (let index = 0, powerOf = 1n; index <= this.MAXIMUM_STRING_LENGTH; index++, powerOf *= baseN) {
+      powersOf[index] = powerOf;
+    }
+    return powersOf;
+  }
+  /**
+   * Get a power of 10.
+   *
+   * @param power
+   * Power.
+   *
+   * @returns
+   * `10**power`.
+   */
+  static powerOf10(power) {
+    return this._powersOf10[power];
+  }
+  /**
+   * Character set size as big integer, cached for performance purposes.
+   */
+  _characterSetSizeN;
+  /**
+   * Character set size minus 1 as big integer, cached for performance purposes.
+   */
+  _characterSetSizeMinusOneN;
+  /**
+   * Domains for every length for every supported {@link Exclusion}.
+   */
+  _exclusionDomains;
+  /**
+   * Values that would generate all zeros in the created string.
+   */
+  _allZerosValues;
+  /**
+   * Constructor.
+   *
+   * @param characterSet
+   * Character set. Each element is a single-character string, unique within the array, that defines the character
+   * set.
+   *
+   * @param exclusionSupport
+   * Exclusions supported by the character set. All character sets implicitly support {@link Exclusion.None}.
+   */
+  constructor(characterSet, ...exclusionSupport) {
+    super(characterSet, ...exclusionSupport);
+    this._characterSetSizeN = BigInt(this.characterSetSize);
+    this._characterSetSizeMinusOneN = BigInt(this.characterSetSize - 1);
+    const exclusionDomains = [];
+    const exclusionNoneDomains = _CharacterSetCreator.createPowersOf(this.characterSetSize);
+    exclusionDomains[0 /* None */] = exclusionNoneDomains;
+    if (exclusionSupport.includes(1 /* FirstZero */)) {
+      if (characterSet[0] !== "0") {
+        throw new RangeError(i18n_default.t("CharacterSetValidator.firstZeroFirstCharacter", {
+          ns: utilityNS
+        }));
+      }
+      const exclusionFirstZeroDomains = new Array(_CharacterSetCreator.MAXIMUM_STRING_LENGTH + 1);
+      exclusionFirstZeroDomains[0] = 0n;
+      for (let index = 1; index <= _CharacterSetCreator.MAXIMUM_STRING_LENGTH; index++) {
+        exclusionFirstZeroDomains[index] = this._characterSetSizeMinusOneN * exclusionNoneDomains[index - 1];
+      }
+      exclusionDomains[1 /* FirstZero */] = exclusionFirstZeroDomains;
+    }
+    if (exclusionSupport.includes(2 /* AllNumeric */)) {
+      const exclusionAllNumericDomains = new Array(_CharacterSetCreator.MAXIMUM_STRING_LENGTH + 1);
+      const numberIndexes = this.characterIndexes("0123456789");
+      let expectedNumberIndex = numberIndexes[0];
+      for (const numberIndex of numberIndexes) {
+        if (numberIndex === void 0 || numberIndex !== expectedNumberIndex) {
+          throw new RangeError(i18n_default.t("CharacterSetValidator.allNumericAllNumericCharacters", {
+            ns: utilityNS
+          }));
+        }
+        expectedNumberIndex = numberIndex + 1;
+      }
+      const zeroIndex = BigInt(numberIndexes[0]);
+      const allZerosValues = new Array(_CharacterSetCreator.MAXIMUM_STRING_LENGTH + 1);
+      let allZerosValue = 0n;
+      for (let index = 0; index <= _CharacterSetCreator.MAXIMUM_STRING_LENGTH; index++) {
+        exclusionAllNumericDomains[index] = exclusionNoneDomains[index] - _CharacterSetCreator.powerOf10(index);
+        allZerosValues[index] = allZerosValue;
+        allZerosValue = allZerosValue * this._characterSetSizeN + zeroIndex;
+      }
+      this._allZerosValues = allZerosValues;
+      exclusionDomains[2 /* AllNumeric */] = exclusionAllNumericDomains;
+    } else {
+      this._allZerosValues = [];
+    }
+    this._exclusionDomains = exclusionDomains;
+  }
+  /**
+   * Get a power of character set size.
+   *
+   * @param power
+   * Power.
+   *
+   * @returns
+   * `characterSetSize**power`.
+   */
+  powerOfSize(power) {
+    return this._exclusionDomains[0 /* None */][power];
+  }
+  /**
+   * Determine the shift required to skip all all-numeric strings up to the value.
+   *
+   * @param shiftForward
+   * True to shift forward (value to string), false to shift backward (string to value).
+   *
+   * @param length
+   * Length of string for which to get the all-numeric shift.
+   *
+   * @param value
+   * Value for which to get the all-numeric shift.
+   *
+   * @returns
+   * Shift required to skip all all-numeric strings.
+   */
+  allNumericShift(shiftForward, length, value) {
+    let shift;
+    if (length === 0) {
+      if (!shiftForward && value < 10n) {
+        throw new RangeError(i18n_default.t("CharacterSetValidator.stringMustNotBeAllNumeric", {
+          ns: utilityNS
+        }));
+      }
+      shift = 10n;
+    } else {
+      const powerOfSize = this.powerOfSize(length);
+      const powerOf10 = _CharacterSetCreator.powerOf10(length);
+      const gap = shiftForward ? powerOfSize - powerOf10 : powerOfSize;
+      const gaps = value / gap;
+      if (gaps >= 10n) {
+        shift = _CharacterSetCreator.powerOf10(length + 1);
+      } else {
+        shift = gaps * powerOf10 + this.allNumericShift(shiftForward, length - 1, value - gaps * gap);
+      }
+    }
+    return shift;
+  }
+  /**
+   * Validate that a length is less than or equal to {@link MAXIMUM_STRING_LENGTH}. If not, an error is thrown.
+   *
+   * @param length
+   * Length.
+   */
+  validateLength(length) {
+    if (length < 0) {
+      throw new RangeError(i18n_default.t("CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo", {
+        ns: utilityNS,
+        length,
+        minimumLength: 0
+      }));
+    }
+    if (length > _CharacterSetCreator.MAXIMUM_STRING_LENGTH) {
+      throw new RangeError(i18n_default.t("CharacterSetValidator.lengthMustBeLessThanOrEqualTo", {
+        ns: utilityNS,
+        length,
+        maximumLength: _CharacterSetCreator.MAXIMUM_STRING_LENGTH
+      }));
+    }
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+  create(length, valueOrValues, exclusion = 0 /* None */, tweak, creationCallback) {
+    this.validateLength(length);
+    this.validateExclusion(exclusion);
+    const allZerosValue = exclusion === 2 /* AllNumeric */ ? this._allZerosValues[length] : 0n;
+    const transformer = Transformer.get(this._exclusionDomains[exclusion][length], tweak);
+    return transformer.forward(valueOrValues, (transformedValue, index) => {
+      let s = "";
+      if (length !== 0) {
+        let convertValue = transformedValue;
+        if (exclusion === 2 /* AllNumeric */ && convertValue >= allZerosValue) {
+          convertValue = convertValue + this.allNumericShift(true, length, convertValue - allZerosValue);
+        }
+        for (let position = length - 1; position > 0; position--) {
+          const nextConvertValue = convertValue / this._characterSetSizeN;
+          s = this.character(Number(convertValue - nextConvertValue * this._characterSetSizeN)) + s;
+          convertValue = nextConvertValue;
+        }
+        s = this.character(exclusion === 1 /* FirstZero */ ? Number(convertValue % this._characterSetSizeMinusOneN) + 1 : Number(convertValue % this._characterSetSizeN)) + s;
+      }
+      return creationCallback !== void 0 ? creationCallback(s, index) : s;
+    });
+  }
+  /**
+   * Determine the value for a string.
+   *
+   * @param s
+   * String.
+   *
+   * @param exclusion
+   * Strings excluded from the range of inputs. See {@link Exclusion} for possible values and their meaning.
+   *
+   * @param tweak
+   * If provided, the numerical value of the string was "tweaked" using an {@link EncryptionTransformer | encryption
+   * transformer}.
+   *
+   * @returns
+   * Numeric value of the string.
+   */
+  valueFor(s, exclusion = 0 /* None */, tweak) {
+    const length = s.length;
+    this.validateLength(length);
+    this.validateExclusion(exclusion);
+    const characterSetSizeN = BigInt(this.characterSetSize);
+    let value = this.characterIndexes(s).reduce((accumulator, characterIndex, index) => {
+      if (characterIndex === void 0) {
+        throw new RangeError(i18n_default.t("CharacterSetValidator.invalidCharacterAtPosition", {
+          ns: utilityNS,
+          c: s.charAt(index),
+          position: index + 1
+        }));
+      }
+      let value2;
+      if (index === 0 && exclusion === 1 /* FirstZero */) {
+        if (characterIndex === 0) {
+          throw new RangeError(i18n_default.t("CharacterSetValidator.invalidCharacterAtPosition", {
+            ns: utilityNS,
+            c: "0",
+            position: 1
+          }));
+        }
+        value2 = BigInt(characterIndex - 1);
+      } else {
+        value2 = accumulator * characterSetSizeN + BigInt(characterIndex);
+      }
+      return value2;
+    }, 0n);
+    if (exclusion === 2 /* AllNumeric */) {
+      const allZerosValue = this._allZerosValues[length];
+      if (value >= allZerosValue) {
+        value -= this.allNumericShift(false, length, value - allZerosValue);
+      }
+    }
+    return Transformer.get(this._exclusionDomains[exclusion][length], tweak).reverse(value);
+  }
+};
+var NUMERIC_CREATOR = new CharacterSetCreator([
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9"
+], 1 /* FirstZero */);
+var HEXADECIMAL_CREATOR = new CharacterSetCreator([
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F"
+], 1 /* FirstZero */, 2 /* AllNumeric */);
+var ALPHABETIC_CREATOR = new CharacterSetCreator([
+  "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"
+]);
+var ALPHANUMERIC_CREATOR = new 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"
+], 1 /* FirstZero */, 2 /* AllNumeric */);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALPHABETIC_CREATOR,
+  ALPHANUMERIC_CREATOR,
+  CharacterSetCreator,
+  CharacterSetValidator,
+  EncryptionTransformer,
+  Exclusion,
+  HEXADECIMAL_CREATOR,
+  IdentityTransformer,
+  IteratorProxy,
+  NUMERIC_CREATOR,
+  RecordValidator,
+  RegExpValidator,
+  Sequencer,
+  Transformer
+});