@mittwald/flow-react-components 0.2.0-alpha.786 → 0.2.0-alpha.788

package/dist/js/_virtual/_.locale.json@95341064edeb0e38b66d786dbd62955c.mjs

@@ -1,82 +1,86 @@
 "use client"
 /* */
-const locales = {"de-DE": {  "button.generate": `Generieren`,
-  "button.generate.tooltip.hide": `Passwort verbergen`,
-  "button.generate.tooltip.show": `Passwort anzeigen`,
-  "password.requirements.heading": `Anforderungen an dein Passwort`,
-  "validation.allowedSpecialCharacters": `Erlaubte Sonderzeichen: #!~%^*_+-=?()<>|.,;\$:/`,
-  "validation.atLeastOneCapitalLetter": `Mindestens ein Großbuchstabe`,
-  "validation.atLeastOneLowercaseLetter": `Mindestens ein Kleinbuchstabe`,
-  "validation.blocklist": (args, formatter) => `${formatter.select({true: `Das Passwort enthält keine verbotenen Wörter.`, other: () => `Das Passwort enthält ein verbotenes Wort "${args.blockedSubstrings}".`}, args.isValid)}`,
-  "validation.blocklist.short": (args, formatter) => `${formatter.select({true: `Keine verbotenen Wörter`, other: () => `Verbotenes Wort "${args.blockedSubstrings}"`}, args.isValid)}`,
-  "validation.canNotStartWithSpecialCharacter": `Darf nicht mit Sonderzeichen anfangen`,
-  "validation.char.max": (args, formatter) => `${formatter.plural(args.max, {one: () => `Bitte verwende maximal ein Zeichen aus [${args.chars}].`, other: () => `Bitte verwende maximal ${args.max} Zeichen aus [${args.chars}].`})}`,
-  "validation.char.max.short": (args, formatter) => `${formatter.plural(args.max, {one: () => `Maximal ein Zeichen aus [${args.chars}].`, other: () => `Maximal ${args.max} Zeichen aus [${args.chars}].`})}`,
-  "validation.char.min": (args, formatter) => `${formatter.plural(args.max, {one: () => `Bitte verwende mindestens ein Zeichen aus [${args.chars}].`, other: () => `Bitte verwende mindestens ${args.min} Zeichen aus [${args.chars}].`})}`,
-  "validation.char.min.short": (args, formatter) => `${formatter.plural(args.max, {one: () => `Mindestens ein Zeichen aus [${args.chars}].`, other: () => `Mindestens ${args.min} Zeichen aus [${args.chars}].`})}`,
-  "validation.charPool.numbers.max": (args, formatter) => `${formatter.plural(args.max, {one: `Bitte verwende maximal eine Zahl.`, other: () => `Bitte verwende maximal ${args.max} Zahlen.`})}`,
-  "validation.charPool.numbers.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximal eine Zahl`, other: () => `Maximal ${args.max} Zahlen`})}`,
-  "validation.charPool.numbers.min": (args, formatter) => `${formatter.plural(args.min, {one: `Bitte verwende mindestens eine Zahl.`, other: () => `Bitte verwende mindestens ${args.min} Zahlen.`})}`,
-  "validation.charPool.numbers.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `Mindestens eine Zahl`, other: () => `Mindestens ${args.min} Zahlen`})}`,
-  "validation.charPool.special.max": (args, formatter) => `${formatter.plural(args.max, {one: `Bitte verwende maximal ein Sonderzeichen.`, other: () => `Bitte verwende maximal ${args.max} Sonderzeichen.`})}`,
-  "validation.charPool.special.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximal ein Sonderzeichen`, other: () => `Maximal ${args.max} Sonderzeichen`})}`,
-  "validation.charPool.special.min": (args, formatter) => `${formatter.plural(args.min, {one: `Bitte verwende mindestens ein Sonderzeichen.`, other: () => `Bitte verwende mindestens ${args.min} Sonderzeichen.`})}`,
-  "validation.charPool.special.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `Mindestens ein Sonderzeichen`, other: () => `Mindestens ${args.min} Sonderzeichen`})}`,
-  "validation.general.failingComplexity": `Bitte erhöhe die Komplexität deines Passwortes.`,
-  "validation.general.optimizeComplexity": `Dein Passwort erfüllt die Minimalanforderungen.`,
-  "validation.general.securePassword": `Sehr gut! Dein Passwort ist sicher.`,
-  "validation.general.short.unspecified": `Keine spezifischen Anforderungen`,
-  "validation.hibp": (args, formatter) => `${formatter.select({true: `Das Passwort ist nicht kompromittiert.`, other: `Das Passwort ist kompromittiert. Bitte vergib ein neues.`}, args.isValid)}`,
-  "validation.hibp.short": (args, formatter) => `${formatter.select({true: `Nicht kompromittiert`, other: `Kompromittiert`}, args.isValid)}`,
-  "validation.length.max": (args, formatter) => `${formatter.plural(args.max, {one: `Bitte wähle ein Passwort mit maximal einem Zeichen.`, other: () => `Bitte wähle ein Passwort mit maximal ${args.max} Zeichen.`})}`,
-  "validation.length.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximal ein Zeichen`, other: () => `Maximal ${args.max} Zeichen`})}`,
-  "validation.length.min": (args, formatter) => `${formatter.plural(args.min, {one: `Bitte wähle ein Passwort mit mindestens einem Zeichen.`, other: () => `Bitte wähle ein Passwort mit mindestens ${args.min} Zeichen.`})}`,
-  "validation.length.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `Mindestens ein Zeichen`, other: () => `Mindestens ${args.min} Zeichen`})}`,
-  "validation.regex.max": (args) => `Bitte verwende das Muster "${args.pattern}" maximal ${args.max} Mal.`,
-  "validation.regex.max.short": (args) => `Muster "${args.pattern}" maximal ${args.max} Mal`,
-  "validation.regex.min": (args) => `Bitte gib ein Passwort nach dem Muster "${args.pattern}" an.`,
-  "validation.regex.min.short": (args) => `Muster "${args.pattern}" nicht vorhanden`,
-  "validation.sequence": `Bitte wähle ein Passwort ohne einfache Zeichenwiederholungen.`,
-  "validation.sequence.short": `Keine einfachen Zeichenwiederholungen`,
-},"en-US": {  "button.generate": `Generate`,
-  "button.generate.tooltip.hide": `Hide password`,
-  "button.generate.tooltip.show": `Show password`,
-  "password.requirements.heading": `Requirements for your password`,
-  "validation.allowedSpecialCharacters": `Allowed special characters: #!~%^*_+-=?()<>|.,;\$:/`,
-  "validation.atLeastOneCapitalLetter": `At least one capital letter`,
-  "validation.atLeastOneLowercaseLetter": `At least one lowercase letter`,
-  "validation.blocklist": (args, formatter) => `${formatter.select({true: `The password does not contain any forbidden words.`, other: () => `The password contains a forbidden word "${args.blockedSubstrings}".`}, args.isValid)}`,
-  "validation.blocklist.short": (args, formatter) => `${formatter.select({true: `No forbidden words`, other: () => `Forbidden word "${args.blockedSubstrings}"`}, args.isValid)}`,
-  "validation.canNotStartWithSpecialCharacter": `Can not start with special character`,
-  "validation.char.max": (args, formatter) => `${formatter.plural(args.max, {one: () => `Please use a maximum of one of the characters [${args.chars}].`, other: () => `Please use a maximum of ${args.max} of the characters [${args.chars}].`})}`,
-  "validation.char.max.short": (args, formatter) => `${formatter.plural(args.max, {one: () => `Maximum one of [${args.chars}]`, other: () => `Maximum ${args.max} of [${args.chars}]`})}`,
-  "validation.char.min": (args, formatter) => `${formatter.plural(args.max, {one: () => `Please use at least one of the characters [${args.chars}].`, other: () => `Please use at least ${args.min} of the characters [${args.chars}].`})}`,
-  "validation.char.min.short": (args, formatter) => `${formatter.plural(args.max, {one: () => `At least one of [${args.chars}]`, other: () => `At least ${args.min} of [${args.chars}]`})}`,
-  "validation.charPool.numbers.max": (args, formatter) => `${formatter.plural(args.max, {one: `Please use a maximum of one number.`, other: () => `Please use a maximum of ${args.max} numbers.`})}`,
-  "validation.charPool.numbers.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximum one number`, other: () => `Maximum ${args.max} numbers`})}`,
-  "validation.charPool.numbers.min": (args, formatter) => `${formatter.plural(args.min, {one: `Please use at least one number.`, other: () => `Please use at least ${args.min} numbers.`})}`,
-  "validation.charPool.numbers.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `At least one number`, other: () => `At least ${args.min} numbers`})}`,
-  "validation.charPool.special.max": (args, formatter) => `${formatter.plural(args.max, {one: `Please use a maximum of one special character.`, other: () => `Please use a maximum of ${args.max} special characters.`})}`,
-  "validation.charPool.special.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximum one special character`, other: () => `Maximum ${args.max} special characters`})}`,
-  "validation.charPool.special.min": (args, formatter) => `${formatter.plural(args.min, {one: `Please use at least one special character.`, other: () => `Please use at least ${args.min} special characters.`})}`,
-  "validation.charPool.special.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `At least one special character`, other: () => `At least ${args.min} special characters`})}`,
-  "validation.general.failingComplexity": `Please increase the complexity of your password.`,
-  "validation.general.optimizeComplexity": `Your password meets the minimum requirements.`,
-  "validation.general.securePassword": `Awesome! Your password is secure.`,
-  "validation.general.short.unspecified": `No specific requirements`,
-  "validation.hibp": (args, formatter) => `${formatter.select({true: `The password is not compromised.`, other: `The password has been compromised. Please set a new one.`}, args.isValid)}`,
-  "validation.hibp.short": (args, formatter) => `${formatter.select({true: `Not compromised`, other: `Compromised`}, args.isValid)}`,
-  "validation.length.max": (args, formatter) => `${formatter.plural(args.max, {one: `Please choose a password with a maximum of one character.`, other: () => `Please choose a password with a maximum of ${args.max} characters.`})}`,
-  "validation.length.max.short": (args, formatter) => `${formatter.plural(args.max, {one: `Maximum one character`, other: () => `Maximum ${args.max} characters`})}`,
-  "validation.length.min": (args, formatter) => `${formatter.plural(args.min, {one: `Please choose a password with at least one character.`, other: () => `Please choose a password with at least ${args.min} characters.`})}`,
-  "validation.length.min.short": (args, formatter) => `${formatter.plural(args.min, {one: `At least one character`, other: () => `At least ${args.min} characters`})}`,
-  "validation.regex.max": (args) => `Please use the pattern "${args.pattern}" a maximum of ${args.max} times.`,
-  "validation.regex.max.short": (args) => `Pattern "${args.pattern}" maximum ${args.max} times`,
-  "validation.regex.min": (args) => `Please enter a password like "${args.pattern}".`,
-  "validation.regex.min.short": (args) => `Pattern "${args.pattern}" not found`,
-  "validation.sequence": `Please choose a password without simple repetitions of characters.`,
-  "validation.sequence.short": `No simple character repetitions`,
-}};
+const locales = {"de-DE":{
+  "button.generate": "Generieren",
+  "button.generate.tooltip.hide": "Passwort verbergen",
+  "button.generate.tooltip.show": "Passwort anzeigen",
+  "password.requirements.heading": "Anforderungen an dein Passwort",
+  "validation.allowedSpecialCharacters": "Erlaubte Sonderzeichen: #!~%^*_+-=?()<>|.,;$:/",
+  "validation.atLeastOneCapitalLetter": "Mindestens ein Großbuchstabe",
+  "validation.atLeastOneLowercaseLetter": "Mindestens ein Kleinbuchstabe",
+  "validation.blocklist": "{isValid, select, true {Das Passwort enthält keine verbotenen Wörter.} other {Das Passwort enthält ein verbotenes Wort \"{blockedSubstrings}\".}}",
+  "validation.blocklist.short": "{isValid, select, true {Keine verbotenen Wörter} other {Verbotenes Wort \"{blockedSubstrings}\"}}",
+  "validation.canNotStartWithSpecialCharacter": "Darf nicht mit Sonderzeichen anfangen",
+  "validation.char.max": "{max, plural, one {Bitte verwende maximal ein Zeichen aus [{chars}].} other {Bitte verwende maximal {max} Zeichen aus [{chars}].}}",
+  "validation.char.max.short": "{max, plural, one {Maximal ein Zeichen aus [{chars}].} other {Maximal {max} Zeichen aus [{chars}].}}",
+  "validation.char.min": "{max, plural, one {Bitte verwende mindestens ein Zeichen aus [{chars}].} other {Bitte verwende mindestens {min} Zeichen aus [{chars}].}}",
+  "validation.char.min.short": "{max, plural, one {Mindestens ein Zeichen aus [{chars}].} other {Mindestens {min} Zeichen aus [{chars}].}}",
+  "validation.charPool.numbers.max": "{max, plural, one {Bitte verwende maximal eine Zahl.} other {Bitte verwende maximal {max} Zahlen.}}",
+  "validation.charPool.numbers.max.short": "{max, plural, one {Maximal eine Zahl} other {Maximal {max} Zahlen}}",
+  "validation.charPool.numbers.min": "{min, plural, one {Bitte verwende mindestens eine Zahl.} other {Bitte verwende mindestens {min} Zahlen.}}",
+  "validation.charPool.numbers.min.short": "{min, plural, one {Mindestens eine Zahl} other {Mindestens {min} Zahlen}}",
+  "validation.charPool.special.max": "{max, plural, one {Bitte verwende maximal ein Sonderzeichen.} other {Bitte verwende maximal {max} Sonderzeichen.}}",
+  "validation.charPool.special.max.short": "{max, plural, one {Maximal ein Sonderzeichen} other {Maximal {max} Sonderzeichen}}",
+  "validation.charPool.special.min": "{min, plural, one {Bitte verwende mindestens ein Sonderzeichen.} other {Bitte verwende mindestens {min} Sonderzeichen.}}",
+  "validation.charPool.special.min.short": "{min, plural, one {Mindestens ein Sonderzeichen} other {Mindestens {min} Sonderzeichen}}",
+  "validation.general.failingComplexity": "Bitte erhöhe die Komplexität deines Passwortes.",
+  "validation.general.optimizeComplexity": "Dein Passwort erfüllt die Minimalanforderungen.",
+  "validation.general.securePassword": "Sehr gut! Dein Passwort ist sicher.",
+  "validation.general.short.unspecified": "Keine spezifischen Anforderungen",
+  "validation.hibp": "{isValid, select, true {Das Passwort ist nicht kompromittiert.} other {Das Passwort ist kompromittiert. Bitte vergib ein neues.}}",
+  "validation.hibp.short": "{isValid, select, true {Nicht kompromittiert} other {Kompromittiert}}",
+  "validation.length.max": "{max, plural, one {Bitte wähle ein Passwort mit maximal einem Zeichen.} other {Bitte wähle ein Passwort mit maximal {max} Zeichen.}}",
+  "validation.length.max.short": "{max, plural, one {Maximal ein Zeichen} other {Maximal {max} Zeichen}}",
+  "validation.length.min": "{min, plural, one {Bitte wähle ein Passwort mit mindestens einem Zeichen.} other {Bitte wähle ein Passwort mit mindestens {min} Zeichen.}}",
+  "validation.length.min.short": "{min, plural, one {Mindestens ein Zeichen} other {Mindestens {min} Zeichen}}",
+  "validation.regex.max": "Bitte verwende das Muster \"{pattern}\" maximal {max} Mal.",
+  "validation.regex.max.short": "Muster \"{pattern}\" maximal {max} Mal",
+  "validation.regex.min": "Bitte gib ein Passwort nach dem Muster \"{pattern}\" an.",
+  "validation.regex.min.short": "Muster \"{pattern}\" nicht vorhanden",
+  "validation.sequence": "Bitte wähle ein Passwort ohne einfache Zeichenwiederholungen.",
+  "validation.sequence.short": "Keine einfachen Zeichenwiederholungen"
+}
+,"en-US":{
+  "button.generate": "Generate",
+  "button.generate.tooltip.hide": "Hide password",
+  "button.generate.tooltip.show": "Show password",
+  "password.requirements.heading": "Requirements for your password",
+  "validation.allowedSpecialCharacters": "Allowed special characters: #!~%^*_+-=?()<>|.,;$:/",
+  "validation.atLeastOneCapitalLetter": "At least one capital letter",
+  "validation.atLeastOneLowercaseLetter": "At least one lowercase letter",
+  "validation.blocklist": "{isValid, select, true {The password does not contain any forbidden words.} other {The password contains a forbidden word \"{blockedSubstrings}\".}}",
+  "validation.blocklist.short": "{isValid, select, true {No forbidden words} other {Forbidden word \"{blockedSubstrings}\"}}",
+  "validation.canNotStartWithSpecialCharacter": "Can not start with special character",
+  "validation.char.max": "{max, plural, one {Please use a maximum of one of the characters [{chars}].} other {Please use a maximum of {max} of the characters [{chars}].}}",
+  "validation.char.max.short": "{max, plural, one {Maximum one of [{chars}]} other {Maximum {max} of [{chars}]}}",
+  "validation.char.min": "{max, plural, one {Please use at least one of the characters [{chars}].} other {Please use at least {min} of the characters [{chars}].}}",
+  "validation.char.min.short": "{max, plural, one {At least one of [{chars}]} other {At least {min} of [{chars}]}}",
+  "validation.charPool.numbers.max": "{max, plural, one {Please use a maximum of one number.} other {Please use a maximum of {max} numbers.}}",
+  "validation.charPool.numbers.max.short": "{max, plural, one {Maximum one number} other {Maximum {max} numbers}}",
+  "validation.charPool.numbers.min": "{min, plural, one {Please use at least one number.} other {Please use at least {min} numbers.}}",
+  "validation.charPool.numbers.min.short": "{min, plural, one {At least one number} other {At least {min} numbers}}",
+  "validation.charPool.special.max": "{max, plural, one {Please use a maximum of one special character.} other {Please use a maximum of {max} special characters.}}",
+  "validation.charPool.special.max.short": "{max, plural, one {Maximum one special character} other {Maximum {max} special characters}}",
+  "validation.charPool.special.min": "{min, plural, one {Please use at least one special character.} other {Please use at least {min} special characters.}}",
+  "validation.charPool.special.min.short": "{min, plural, one {At least one special character} other {At least {min} special characters}}",
+  "validation.general.failingComplexity": "Please increase the complexity of your password.",
+  "validation.general.optimizeComplexity": "Your password meets the minimum requirements.",
+  "validation.general.securePassword": "Awesome! Your password is secure.",
+  "validation.general.short.unspecified": "No specific requirements",
+  "validation.hibp": "{isValid, select, true {The password is not compromised.} other {The password has been compromised. Please set a new one.}}",
+  "validation.hibp.short": "{isValid, select, true {Not compromised} other {Compromised}}",
+  "validation.length.max": "{max, plural, one {Please choose a password with a maximum of one character.} other {Please choose a password with a maximum of {max} characters.}}",
+  "validation.length.max.short": "{max, plural, one {Maximum one character} other {Maximum {max} characters}}",
+  "validation.length.min": "{min, plural, one {Please choose a password with at least one character.} other {Please choose a password with at least {min} characters.}}",
+  "validation.length.min.short": "{min, plural, one {At least one character} other {At least {min} characters}}",
+  "validation.regex.max": "Please use the pattern \"{pattern}\" a maximum of {max} times.",
+  "validation.regex.max.short": "Pattern \"{pattern}\" maximum {max} times",
+  "validation.regex.min": "Please enter a password like \"{pattern}\".",
+  "validation.regex.min.short": "Pattern \"{pattern}\" not found",
+  "validation.sequence": "Please choose a password without simple repetitions of characters.",
+  "validation.sequence.short": "No simple character repetitions"
+}
+};
 
 export { locales as default };
 //# sourceMappingURL=_.locale.json@95341064edeb0e38b66d786dbd62955c.mjs.map

package/dist/js/_virtual/_.locale.json@95341064edeb0e38b66d786dbd62955c.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_.locale.json@95341064edeb0e38b66d786dbd62955c.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"_.locale.json@95341064edeb0e38b66d786dbd62955c.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/js/_virtual/_.locale.json@bb0db7b5021f874310cbe5b6cc3d9cac.mjs

@@ -1,26 +1,30 @@
 "use client"
 /* */
-const locales = {"de-DE": {  "mode.editor": `Vorschau beenden`,
-  "mode.preview": `Vorschau`,
-  "toolbar.bold": `Fett`,
-  "toolbar.code": `Code`,
-  "toolbar.italic": `Kursiv`,
-  "toolbar.link": `Link`,
-  "toolbar.orderedList": `Sortierte Liste`,
-  "toolbar.quote": `Zitat`,
-  "toolbar.strikeThrough": `Durchgestrichen`,
-  "toolbar.unorderedList": `Liste`,
-},"en-US": {  "mode.editor": `Exit Preview`,
-  "mode.preview": `Preview`,
-  "toolbar.bold": `Bold`,
-  "toolbar.code": `Code`,
-  "toolbar.italic": `Italic`,
-  "toolbar.link": `Link`,
-  "toolbar.orderedList": `Ordered List`,
-  "toolbar.quote": `Quote`,
-  "toolbar.strikeThrough": `Strike through`,
-  "toolbar.unorderedList": `List`,
-}};
+const locales = {"de-DE":{
+  "mode.editor": "Vorschau beenden",
+  "mode.preview": "Vorschau",
+  "toolbar.bold": "Fett",
+  "toolbar.code": "Code",
+  "toolbar.italic": "Kursiv",
+  "toolbar.link": "Link",
+  "toolbar.orderedList": "Sortierte Liste",
+  "toolbar.quote": "Zitat",
+  "toolbar.strikeThrough": "Durchgestrichen",
+  "toolbar.unorderedList": "Liste"
+}
+,"en-US":{
+  "mode.editor": "Exit Preview",
+  "mode.preview": "Preview",
+  "toolbar.bold": "Bold",
+  "toolbar.code": "Code",
+  "toolbar.italic": "Italic",
+  "toolbar.link": "Link",
+  "toolbar.orderedList": "Ordered List",
+  "toolbar.quote": "Quote",
+  "toolbar.strikeThrough": "Strike through",
+  "toolbar.unorderedList": "List"
+}
+};
 
 export { locales as default };
 //# sourceMappingURL=_.locale.json@bb0db7b5021f874310cbe5b6cc3d9cac.mjs.map

package/dist/js/_virtual/_.locale.json@bb0db7b5021f874310cbe5b6cc3d9cac.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_.locale.json@bb0db7b5021f874310cbe5b6cc3d9cac.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"_.locale.json@bb0db7b5021f874310cbe5b6cc3d9cac.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}