@aidc-toolkit/utility 0.9.13-beta → 0.9.15-beta

package/dist/index.js

@@ -1,4 +1,1291 @@
-import{i18nAssertValidResources as v,i18nCoreInit as w}from"@aidc-toolkit/core";import A from"i18next";var E={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}}",minimumValueMustBeGreaterThanOrEqualToZero:"Minimum value {{minimumValue}} must be greater than or equal to 0",maximumValueMustBeLessThan:"Maximum value {{maximumValue}} 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'}};var S={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}}",minimumValueMustBeGreaterThanOrEqualToZero:"La valeur minimale {{minimumValue}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 0",maximumValueMustBeLessThan:"La valeur maximale {{maximumValue}} 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'}};var B="aidct_utility";v(E,"fr",S);var V={en:{aidct_utility:E},fr:{aidct_utility:S}},u=A.createInstance();async function F(i,e=!1){await w(u,i,e,B,V)}var T=class{_startValue;_endValue;_count;_nextDelta;_minimumValue;_maximumValue;constructor(e,t){this._startValue=BigInt(e),this._endValue=this._startValue+BigInt(t),this._count=t,t>=0?(this._nextDelta=1n,this._minimumValue=this._startValue,this._maximumValue=this._endValue-1n):(this._nextDelta=-1n,this._minimumValue=this._endValue+1n,this._maximumValue=this._startValue)}get startValue(){return this._startValue}get endValue(){return this._endValue}get count(){return this._count}get minimumValue(){return this._minimumValue}get maximumValue(){return this._maximumValue}*[Symbol.iterator](){for(let e=this._startValue;e!==this._endValue;e+=this._nextDelta)yield e}};function b(i,e){return{*[Symbol.iterator](){let t=0;for(let r of i)yield e(r,t++)}}}var g=class i{static TRANSFORMER_MAPS_MAP=new Map;_domain;constructor(e){if(this._domain=BigInt(e),this._domain<=0n)throw new RangeError(u.t("Transformer.domainMustBeGreaterThanZero",{domain:e}))}static get(e,t){let r=BigInt(e),n=i.TRANSFORMER_MAPS_MAP.get(r);n===void 0&&(n=new Map,i.TRANSFORMER_MAPS_MAP.set(r,n));let a=t===void 0?void 0:BigInt(t),o=n.get(a);return o===void 0&&(o=a===void 0?new N(r):new M(r,a),n.set(a,o)),o}get domain(){return this._domain}validate(e){if(e<0n)throw new RangeError(u.t("Transformer.valueMustBeGreaterThanOrEqualToZero",{value:e}));if(e>=this.domain)throw new RangeError(u.t("Transformer.valueMustBeLessThan",{value:e,domain:this.domain}))}validateDoForward(e){let t=BigInt(e);return this.validate(t),this.doForward(t)}validateDoForwardCallback(e,t,r){return e(this.validateDoForward(t),r)}forward(e,t){let r;if(typeof e!="object")r=t===void 0?this.validateDoForward(e):this.validateDoForwardCallback(t,e,0);else if(e instanceof T){if(e.minimumValue<0n)throw new RangeError(u.t("Transformer.minimumValueMustBeGreaterThanOrEqualToZero",{minimumValue:e.minimumValue}));if(e.maximumValue>=this.domain)throw new RangeError(u.t("Transformer.maximumValueMustBeLessThan",{maximumValue:e.maximumValue,domain:this.domain}));r=t===void 0?b(e,n=>this.doForward(n)):b(e,(n,a)=>t(this.doForward(n),a))}else r=t===void 0?b(e,n=>this.validateDoForward(n)):b(e,(n,a)=>this.validateDoForwardCallback(t,n,a));return r}reverse(e){let t=BigInt(e);return this.validate(t),this.doReverse(t)}},N=class extends g{doForward(e){return e}doReverse(e){return e}},M=class i extends g{static BITS=new Uint8Array([1,2,4,8,16,32,64,128]);static INVERSE_BITS=new Uint8Array([254,253,251,247,239,223,191,127]);_domainBytes;_xorBytes;_bits;_inverseBits;_rounds;constructor(e,t){if(super(e),t<0n)throw new RangeError(u.t("Transformer.tweakMustBeGreaterThanOrEqualToZero",{tweak:t}));let r=0;for(let s=this.domain-1n;s!==0n;s>>=8n)r++;this._domainBytes=r;let n=new Array,a=new Array,o=new Array;for(let s=this.domain*BigInt(t)*603868999n;s!==0n;s>>=8n){n.unshift(Number(BigInt.asUintN(8,s)));let l=Number(BigInt.asUintN(3,s));a.push(i.BITS[l]),o.push(i.INVERSE_BITS[l])}if(r===1){let s=i.BITS.filter(l=>l<e).reduce((l,h)=>l|h,0);this._xorBytes=new Uint8Array([n.reduce((l,h)=>l^h,0)&s]),this._bits=new Uint8Array([i.BITS[0]]),this._inverseBits=new Uint8Array([i.INVERSE_BITS[0]]),this._rounds=1}else this._xorBytes=new Uint8Array(n),this._bits=new Uint8Array(a),this._inverseBits=new Uint8Array(o),this._rounds=n.length}valueToBytes(e){let t=new Uint8Array(this._domainBytes);for(let r=this._domainBytes-1,n=e;r>=0&&n!==0n;r--,n>>=8n)t[r]=Number(BigInt.asUintN(8,n));return t}static bytesToValue(e){return e.reduce((t,r)=>t<<8n|BigInt(r),0n)}shuffle(e,t,r){let n=e.length,a=new Uint8Array(n),o=new Array,s=new Array,l=this._bits[t];e.forEach((m,c)=>{let p=m&l;a[c]=p,(p!==0?o:s).push(c)});let h=this._inverseBits[t],d=new Uint8Array(n);return[...o,...s].forEach((m,c)=>{r?d[c]=e[m]&h|a[c]:d[m]=e[c]&h|a[m]}),d}xor(e,t,r){let n=this._xorBytes[t];return e.map(a=>{let o=a^n;return n=r?o:a,o})}doForward(e){let t=this.valueToBytes(e),r;do{for(let n=0;n<this._rounds;n++)t=this.xor(this.shuffle(t,n,!0),n,!0);r=i.bytesToValue(t)}while(r>=this.domain);return r}doReverse(e){let t=this.valueToBytes(e),r;do{for(let n=this._rounds-1;n>=0;n--)t=this.shuffle(this.xor(t,n,!1),n,!1);r=i.bytesToValue(t)}while(r>=this.domain);return r}};var x=class{_regExp;constructor(e){this._regExp=e}get regExp(){return this._regExp}createErrorMessage(e){return u.t("RegExpValidator.stringDoesNotMatchPattern",{s:e})}validate(e){if(!this._regExp.test(e))throw new RangeError(this.createErrorMessage(e))}};var _=class{_typeName;_record;constructor(e,t){this._typeName=e,this._record=t}get typeName(){return this._typeName}get record(){return this._record}validate(e){if(!(e in this.record))throw new RangeError(u.t("RecordValidator.typeNameKeyNotFound",{typeName:this.typeName,key:e}))}};var O=(r=>(r[r.None=0]="None",r[r.FirstZero=1]="FirstZero",r[r.AllNumeric=2]="AllNumeric",r))(O||{}),I=class i{static NOT_ALL_NUMERIC_VALIDATOR=new class extends x{createErrorMessage(e){return u.t("CharacterSetValidator.stringMustNotBeAllNumeric")}}(/\D/);_characterSet;_characterSetMap;_exclusionSupport;constructor(e,...t){this._characterSet=e;let r=new Map;e.forEach((n,a)=>{r.set(n,a)}),this._characterSetMap=r,this._exclusionSupport=t}get characterSet(){return this._characterSet}get characterSetSize(){return this._characterSet.length}get exclusionSupport(){return this._exclusionSupport}character(e){return this._characterSet[e]}characterIndex(e){return this._characterSetMap.get(e)}characterIndexes(e){return Array.from(e).map(t=>this._characterSetMap.get(t))}static componentToString(e){return typeof e=="function"?e():e}validateExclusion(e){if(e!==0&&!this._exclusionSupport.includes(e))throw new RangeError(u.t("CharacterSetValidator.exclusionNotSupported",{exclusion:e}))}validate(e,t){let r=e.length,n=t?.minimumLength,a=t?.maximumLength;if(n!==void 0&&r<n){let s;throw a!==void 0&&a===n?s=u.t(t?.component===void 0?"CharacterSetValidator.lengthMustBeEqualTo":"CharacterSetValidator.lengthOfComponentMustBeEqualTo",{component:i.componentToString(t?.component),length:r,exactLength:n}):s=u.t(t?.component===void 0?"CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo":"CharacterSetValidator.lengthOfComponentMustBeGreaterThanOrEqualTo",{component:i.componentToString(t?.component),length:r,minimumLength:n}),new RangeError(s)}if(a!==void 0&&r>a)throw new RangeError(u.t(t?.component===void 0?"CharacterSetValidator.lengthMustBeLessThanOrEqualTo":"CharacterSetValidator.lengthOfComponentMustBeLessThanOrEqualTo",{component:i.componentToString(t?.component),length:r,maximumLength:a}));let o=this.characterIndexes(e).findIndex(s=>s===void 0);if(o!==-1)throw new RangeError(u.t(t?.component===void 0?"CharacterSetValidator.invalidCharacterAtPosition":"CharacterSetValidator.invalidCharacterAtPositionOfComponent",{component:i.componentToString(t?.component),c:e.charAt(o),position:o+(t?.positionOffset??0)+1}));if(t?.exclusion!==void 0)switch(this.validateExclusion(t.exclusion),t.exclusion){case 0:break;case 1:if(e.startsWith("0"))throw new RangeError(u.t(t.component===void 0?"CharacterSetValidator.invalidCharacterAtPosition":"CharacterSetValidator.invalidCharacterAtPositionOfComponent",{component:i.componentToString(t.component),c:"0",position:(t.positionOffset??0)+1}));break;case 2:i.NOT_ALL_NUMERIC_VALIDATOR.validate(e);break}}},f=class i extends I{static MAXIMUM_STRING_LENGTH=40;static _powersOf10=i.createPowersOf(10);static createPowersOf(e){let t=new Array(this.MAXIMUM_STRING_LENGTH+1),r=BigInt(e);for(let n=0,a=1n;n<=this.MAXIMUM_STRING_LENGTH;n++,a*=r)t[n]=a;return t}static powerOf10(e){return this._powersOf10[e]}_characterSetSizeN;_characterSetSizeMinusOneN;_exclusionDomains;_allZerosValues;constructor(e,...t){super(e,...t),this._characterSetSizeN=BigInt(this.characterSetSize),this._characterSetSizeMinusOneN=BigInt(this.characterSetSize-1);let r=[],n=i.createPowersOf(this.characterSetSize);if(r[0]=n,t.includes(1)){if(e[0]!=="0")throw new RangeError(u.t("CharacterSetValidator.firstZeroFirstCharacter"));let o=new Array(i.MAXIMUM_STRING_LENGTH+1);o[0]=0n;for(let s=1;s<=i.MAXIMUM_STRING_LENGTH;s++)o[s]=this._characterSetSizeMinusOneN*n[s-1];r[1]=o}if(t.includes(2)){let s=function(c){let p=c[0];for(let y of c){if(y===void 0||y!==p)throw new RangeError(u.t("CharacterSetValidator.allNumericAllNumericCharacters"));p=y+1}};var a=s;let o=new Array(i.MAXIMUM_STRING_LENGTH+1),l=this.characterIndexes("0123456789");s(l);let h=BigInt(l[0]),d=new Array(i.MAXIMUM_STRING_LENGTH+1),m=0n;for(let c=0;c<=i.MAXIMUM_STRING_LENGTH;c++)o[c]=n[c]-i.powerOf10(c),d[c]=m,m=m*this._characterSetSizeN+h;this._allZerosValues=d,r[2]=o}else this._allZerosValues=[];this._exclusionDomains=r}powerOfSize(e){return this._exclusionDomains[0][e]}allNumericShift(e,t,r){let n;if(t===0){if(!e&&r<10n)throw new RangeError(u.t("CharacterSetValidator.stringMustNotBeAllNumeric"));n=10n}else{let a=this.powerOfSize(t),o=i.powerOf10(t),s=e?a-o:a,l=r/s;l>=10n?n=i.powerOf10(t+1):n=l*o+this.allNumericShift(e,t-1,r-l*s)}return n}validateLength(e){if(e<0)throw new RangeError(u.t("CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo",{length:e,minimumLength:0}));if(e>i.MAXIMUM_STRING_LENGTH)throw new RangeError(u.t("CharacterSetValidator.lengthMustBeLessThanOrEqualTo",{length:e,maximumLength:i.MAXIMUM_STRING_LENGTH}))}create(e,t,r=0,n,a){this.validateLength(e),this.validateExclusion(r);let o=r===2?this._allZerosValues[e]:0n;return g.get(this._exclusionDomains[r][e],n).forward(t,(l,h)=>{let d="";if(e!==0){let m=l;r===2&&m>=o&&(m=m+this.allNumericShift(!0,e,m-o));for(let c=e-1;c>0;c--){let p=m/this._characterSetSizeN;d=this.character(Number(m-p*this._characterSetSizeN))+d,m=p}d=this.character(r===1?Number(m%this._characterSetSizeMinusOneN)+1:Number(m%this._characterSetSizeN))+d}return a===void 0?d:a(d,h)})}valueFor(e,t=0,r){let n=e.length;this.validateLength(n),this.validateExclusion(t);let a=BigInt(this.characterSetSize),o=this.characterIndexes(e).reduce((s,l,h)=>{if(l===void 0)throw new RangeError(u.t("CharacterSetValidator.invalidCharacterAtPosition",{c:e.charAt(h),position:h+1}));let d;if(h===0&&t===1){if(l===0)throw new RangeError(u.t("CharacterSetValidator.invalidCharacterAtPosition",{c:"0",position:1}));d=BigInt(l-1)}else d=s*a+BigInt(l);return d},0n);if(t===2){let s=this._allZerosValues[n];o>=s&&(o-=this.allNumericShift(!1,n,o-s))}return g.get(this._exclusionDomains[t][n],r).reverse(o)}},Y=new f(["0","1","2","3","4","5","6","7","8","9"],1),$=new f(["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"],1,2),ee=new f(["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"]),te=new f(["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,2);export{ee as ALPHABETIC_CREATOR,te as ALPHANUMERIC_CREATOR,f as CharacterSetCreator,I as CharacterSetValidator,M as EncryptionTransformer,O as Exclusion,$ as HEXADECIMAL_CREATOR,N as IdentityTransformer,Y as NUMERIC_CREATOR,_ as RecordValidator,x as RegExpValidator,T as Sequence,g as Transformer,F as i18nUtilityInit,u as i18nextUtility,b as transformIterable,B as utilityNS,V as utilityResources};
+// src/locale/i18n.ts
+import { i18nAssertValidResources, i18nCoreInit } from "@aidc-toolkit/core";
+import i18next from "i18next";
+
+// 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}}",
+    minimumValueMustBeGreaterThanOrEqualToZero: "Minimum value {{minimumValue}} must be greater than or equal to 0",
+    maximumValueMustBeLessThan: "Maximum value {{maximumValue}} 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}}",
+    minimumValueMustBeGreaterThanOrEqualToZero: "La valeur minimale {{minimumValue}} doit \xEAtre sup\xE9rieure ou \xE9gale \xE0 0",
+    maximumValueMustBeLessThan: "La valeur maximale {{maximumValue}} 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";
+i18nAssertValidResources(localeStrings, "fr", localeStrings2);
+var utilityResources = {
+  en: {
+    aidct_utility: localeStrings
+  },
+  fr: {
+    aidct_utility: localeStrings2
+  }
+};
+var i18nextUtility = i18next.createInstance();
+async function i18nUtilityInit(environment, debug = false) {
+  await i18nCoreInit(i18nextUtility, environment, debug, utilityNS, utilityResources);
+}
+
+// src/sequence.ts
+var Sequence = 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).
+   */
+  _minimumValue;
+  /**
+   * Maximum value (inclusive).
+   */
+  _maximumValue;
+  /**
+   * 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;
+    if (count >= 0) {
+      this._nextDelta = 1n;
+      this._minimumValue = this._startValue;
+      this._maximumValue = this._endValue - 1n;
+    } else {
+      this._nextDelta = -1n;
+      this._minimumValue = this._endValue + 1n;
+      this._maximumValue = 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 minimumValue() {
+    return this._minimumValue;
+  }
+  /**
+   * Get the maximum value (inclusive).
+   */
+  get maximumValue() {
+    return this._maximumValue;
+  }
+  /**
+   * Iterable implementation.
+   *
+   * @yields
+   * Next value in sequence.
+   */
+  *[Symbol.iterator]() {
+    for (let value = this._startValue; value !== this._endValue; value += this._nextDelta) {
+      yield value;
+    }
+  }
+};
+
+// src/transformer.ts
+function transformIterable(values, transformerCallback) {
+  return {
+    /**
+     * Iterable implementation.
+     *
+     * @yields
+     * Next output value.
+     */
+    *[Symbol.iterator]() {
+      let index = 0;
+      for (const value of values) {
+        yield transformerCallback(value, index++);
+      }
+    }
+  };
+}
+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(i18nextUtility.t("Transformer.domainMustBeGreaterThanZero", {
+        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(i18nextUtility.t("Transformer.valueMustBeGreaterThanOrEqualToZero", {
+        value
+      }));
+    }
+    if (value >= this.domain) {
+      throw new RangeError(i18nextUtility.t("Transformer.valueMustBeLessThan", {
+        value,
+        domain: this.domain
+      }));
+    }
+  }
+  /**
+   * Validate that a value is within the domain and do the work of transforming it forward.
+   *
+   * @param value
+   * Value.
+   *
+   * @returns
+   * Transformed value.
+   */
+  validateDoForward(value) {
+    const valueN = BigInt(value);
+    this.validate(valueN);
+    return this.doForward(valueN);
+  }
+  /**
+   * Validate that a value is within the domain, do the work of transforming it forward, and apply a callback.
+   *
+   * @param transformerCallback
+   * Called after each value is transformed to convert it to its final value.
+   *
+   * @param value
+   * Value.
+   *
+   * @param index
+   * Index in sequence (0 for single transformation).
+   *
+   * @returns
+   * Transformed value.
+   */
+  validateDoForwardCallback(transformerCallback, value, index) {
+    return transformerCallback(this.validateDoForward(value), index);
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+  forward(valueOrValues, transformerCallback) {
+    let result;
+    if (typeof valueOrValues !== "object") {
+      result = transformerCallback === void 0 ? this.validateDoForward(valueOrValues) : this.validateDoForwardCallback(transformerCallback, valueOrValues, 0);
+    } else if (valueOrValues instanceof Sequence) {
+      if (valueOrValues.minimumValue < 0n) {
+        throw new RangeError(i18nextUtility.t("Transformer.minimumValueMustBeGreaterThanOrEqualToZero", {
+          minimumValue: valueOrValues.minimumValue
+        }));
+      }
+      if (valueOrValues.maximumValue >= this.domain) {
+        throw new RangeError(i18nextUtility.t("Transformer.maximumValueMustBeLessThan", {
+          maximumValue: valueOrValues.maximumValue,
+          domain: this.domain
+        }));
+      }
+      result = transformerCallback === void 0 ? transformIterable(valueOrValues, (value) => this.doForward(value)) : transformIterable(valueOrValues, (value, index) => transformerCallback(this.doForward(value), index));
+    } else {
+      result = transformerCallback === void 0 ? transformIterable(valueOrValues, (value) => this.validateDoForward(value)) : transformIterable(valueOrValues, (value, index) => this.validateDoForwardCallback(transformerCallback, value, 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;
+  /**
+   * 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(i18nextUtility.t("Transformer.tweakMustBeGreaterThanOrEqualToZero", {
+        tweak
+      }));
+    }
+    let domainBytes = 0;
+    for (let reducedDomainMinusOne = this.domain - 1n; reducedDomainMinusOne !== 0n; reducedDomainMinusOne >>= 8n) {
+      domainBytes++;
+    }
+    this._domainBytes = domainBytes;
+    const xorBytes = new Array();
+    const bits = new Array();
+    const inverseBits = new Array();
+    for (let reducedKey = this.domain * BigInt(tweak) * 603868999n; reducedKey !== 0n; reducedKey >>= 8n) {
+      xorBytes.unshift(Number(BigInt.asUintN(8, reducedKey)));
+      const bitNumber = Number(BigInt.asUintN(3, reducedKey));
+      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;
+    }
+  }
+  /**
+   * 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);
+    for (let index = this._domainBytes - 1, reducedValue = value; index >= 0 && reducedValue !== 0n; index--, reducedValue >>= 8n) {
+      bytes[index] = Number(BigInt.asUintN(8, reducedValue));
+    }
+    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 i18nextUtility.t("RegExpValidator.stringDoesNotMatchPattern", {
+      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 (!(key in this.record)) {
+      throw new RangeError(i18nextUtility.t("RecordValidator.typeNameKeyNotFound", {
+        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 i18nextUtility.t("CharacterSetValidator.stringMustNotBeAllNumeric");
+    }
+  }(/\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 Array.from(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(i18nextUtility.t("CharacterSetValidator.exclusionNotSupported", {
+        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 = i18nextUtility.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeEqualTo", {
+          component: _CharacterSetValidator.componentToString(validation?.component),
+          length,
+          exactLength: minimumLength
+        });
+      } else {
+        errorMessage = i18nextUtility.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeGreaterThanOrEqualTo", {
+          component: _CharacterSetValidator.componentToString(validation?.component),
+          length,
+          minimumLength
+        });
+      }
+      throw new RangeError(errorMessage);
+    }
+    if (maximumLength !== void 0 && length > maximumLength) {
+      throw new RangeError(i18nextUtility.t(validation?.component === void 0 ? "CharacterSetValidator.lengthMustBeLessThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeLessThanOrEqualTo", {
+        component: _CharacterSetValidator.componentToString(validation?.component),
+        length,
+        maximumLength
+      }));
+    }
+    const index = this.characterIndexes(s).findIndex((characterIndex) => characterIndex === void 0);
+    if (index !== -1) {
+      throw new RangeError(i18nextUtility.t(validation?.component === void 0 ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
+        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(i18nextUtility.t(validation.component === void 0 ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
+              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(i18nextUtility.t("CharacterSetValidator.firstZeroFirstCharacter"));
+      }
+      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 */)) {
+      let validateNumberIndexes2 = function(numberIndexes2) {
+        let expectedNumberIndex = numberIndexes2[0];
+        for (const numberIndex of numberIndexes2) {
+          if (numberIndex === void 0 || numberIndex !== expectedNumberIndex) {
+            throw new RangeError(i18nextUtility.t("CharacterSetValidator.allNumericAllNumericCharacters"));
+          }
+          expectedNumberIndex = numberIndex + 1;
+        }
+      };
+      var validateNumberIndexes = validateNumberIndexes2;
+      const exclusionAllNumericDomains = new Array(_CharacterSetCreator.MAXIMUM_STRING_LENGTH + 1);
+      const numberIndexes = this.characterIndexes("0123456789");
+      validateNumberIndexes2(numberIndexes);
+      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(i18nextUtility.t("CharacterSetValidator.stringMustNotBeAllNumeric"));
+      }
+      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(i18nextUtility.t("CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo", {
+        length,
+        minimumLength: 0
+      }));
+    }
+    if (length > _CharacterSetCreator.MAXIMUM_STRING_LENGTH) {
+      throw new RangeError(i18nextUtility.t("CharacterSetValidator.lengthMustBeLessThanOrEqualTo", {
+        length,
+        maximumLength: _CharacterSetCreator.MAXIMUM_STRING_LENGTH
+      }));
+    }
+  }
+  /**
+   * Create string(s) by mapping value(s) to the equivalent characters in the character set across the length of the
+   * string.
+   *
+   * @param length
+   * Required string length.
+   *
+   * @param valueOrValues
+   * Numeric value(s) of the string(s).
+   *
+   * @param exclusion
+   * String(s) to be excluded from the range of outputs. See {@link Exclusion} for possible values and their meaning.
+   *
+   * @param tweak
+   * If provided, the numerical value of the string(s) is/are "tweaked" using an {@link EncryptionTransformer |
+   * encryption transformer}.
+   *
+   * @param creatorCallback
+   * If provided, called after each string is constructed to create the final value.
+   *
+   * @returns
+   * String(s) created from the value(s).
+   */
+  create(length, valueOrValues, exclusion = 0 /* None */, tweak, creatorCallback) {
+    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 creatorCallback === void 0 ? s : creatorCallback(s, index);
+    });
+  }
+  /**
+   * 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(i18nextUtility.t("CharacterSetValidator.invalidCharacterAtPosition", {
+          c: s.charAt(index),
+          position: index + 1
+        }));
+      }
+      let value2;
+      if (index === 0 && exclusion === 1 /* FirstZero */) {
+        if (characterIndex === 0) {
+          throw new RangeError(i18nextUtility.t("CharacterSetValidator.invalidCharacterAtPosition", {
+            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 */);
+export {
+  ALPHABETIC_CREATOR,
+  ALPHANUMERIC_CREATOR,
+  CharacterSetCreator,
+  CharacterSetValidator,
+  EncryptionTransformer,
+  Exclusion,
+  HEXADECIMAL_CREATOR,
+  IdentityTransformer,
+  NUMERIC_CREATOR,
+  RecordValidator,
+  RegExpValidator,
+  Sequence,
+  Transformer,
+  i18nUtilityInit,
+  i18nextUtility,
+  transformIterable,
+  utilityNS,
+  utilityResources
+};
 /*!
  * Copyright © 2024-2025 Dolphin Data Development Ltd. and AIDC Toolkit
  * contributors