@starterlib/ui 0.8.0 → 0.9.1

package/fesm2022/starterlib-ui-qr.mjs

@@ -0,0 +1,907 @@
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, afterNextRender, computed, input, isDevMode, viewChild } from "@angular/core";
+const INDICATEUR_DE_MODE = {
+	numerique: 1,
+	alphanumerique: 2,
+	octets: 4
+};
+const BITS_DU_COMPTE = {
+	numerique: [
+		10,
+		12,
+		14
+	],
+	alphanumerique: [
+		9,
+		11,
+		13
+	],
+	octets: [
+		8,
+		16,
+		16
+	]
+};
+const ALPHANUMERIQUE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+const BITS_DU_NIVEAU = {
+	L: 1,
+	M: 0,
+	Q: 3,
+	H: 2
+};
+const CORRECTION_PAR_BLOC = {
+	L: [
+		-1,
+		7,
+		10,
+		15,
+		20,
+		26,
+		18,
+		20,
+		24,
+		30,
+		18,
+		20,
+		24,
+		26,
+		30,
+		22,
+		24,
+		28,
+		30,
+		28,
+		28,
+		28,
+		28,
+		30,
+		30,
+		26,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	M: [
+		-1,
+		10,
+		16,
+		26,
+		18,
+		24,
+		16,
+		18,
+		22,
+		22,
+		26,
+		30,
+		22,
+		22,
+		24,
+		24,
+		28,
+		28,
+		26,
+		26,
+		26,
+		26,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28
+	],
+	Q: [
+		-1,
+		13,
+		22,
+		18,
+		26,
+		18,
+		24,
+		18,
+		22,
+		20,
+		24,
+		28,
+		26,
+		24,
+		20,
+		30,
+		24,
+		28,
+		28,
+		26,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	H: [
+		-1,
+		17,
+		28,
+		22,
+		16,
+		22,
+		28,
+		26,
+		26,
+		24,
+		28,
+		24,
+		28,
+		22,
+		24,
+		24,
+		30,
+		28,
+		28,
+		26,
+		28,
+		30,
+		24,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	]
+};
+const BLOCS = {
+	L: [
+		-1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		2,
+		2,
+		4,
+		4,
+		4,
+		4,
+		4,
+		6,
+		6,
+		6,
+		6,
+		7,
+		8,
+		8,
+		9,
+		9,
+		10,
+		12,
+		12,
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19,
+		19,
+		20,
+		21,
+		22,
+		24,
+		25
+	],
+	M: [
+		-1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		4,
+		5,
+		5,
+		5,
+		8,
+		9,
+		9,
+		10,
+		10,
+		11,
+		13,
+		14,
+		16,
+		17,
+		17,
+		18,
+		20,
+		21,
+		23,
+		25,
+		26,
+		28,
+		29,
+		31,
+		33,
+		35,
+		37,
+		38,
+		40,
+		43,
+		45,
+		47,
+		49
+	],
+	Q: [
+		-1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		6,
+		6,
+		8,
+		8,
+		8,
+		10,
+		12,
+		16,
+		12,
+		17,
+		16,
+		18,
+		21,
+		20,
+		23,
+		23,
+		25,
+		27,
+		29,
+		34,
+		34,
+		35,
+		38,
+		40,
+		43,
+		45,
+		48,
+		51,
+		53,
+		56,
+		59,
+		62,
+		65,
+		68
+	],
+	H: [
+		-1,
+		1,
+		1,
+		2,
+		4,
+		4,
+		4,
+		5,
+		6,
+		8,
+		8,
+		11,
+		11,
+		16,
+		16,
+		18,
+		16,
+		19,
+		21,
+		25,
+		25,
+		25,
+		34,
+		30,
+		32,
+		35,
+		37,
+		40,
+		42,
+		45,
+		48,
+		51,
+		54,
+		57,
+		60,
+		63,
+		66,
+		70,
+		74,
+		77,
+		81
+	]
+};
+const PENALITE_SUITE = 3;
+const PENALITE_CARRE = 3;
+const PENALITE_REPERE = 40;
+const PENALITE_EQUILIBRE = 10;
+const VERSION_MIN = 1;
+const VERSION_MAX = 40;
+function entree(table, indice) {
+	const valeur = table[indice];
+	if (valeur === void 0 || valeur < 0) throw new RangeError(`encoderQr : indice ${String(indice)} hors des tables`);
+	return valeur;
+}
+function encoderQr(texte, options = {}) {
+	const correction = options.correction ?? "M";
+	const versionMin = options.versionMin ?? VERSION_MIN;
+	const versionMax = options.versionMax ?? VERSION_MAX;
+	if (!Number.isInteger(versionMin) || !Number.isInteger(versionMax) || versionMin < VERSION_MIN || versionMax > VERSION_MAX || versionMin > versionMax) throw new RangeError(`encoderQr : versions ${String(versionMin)} a ${String(versionMax)} hors de 1 a 40`);
+	const masqueImpose = options.masque ?? null;
+	if (masqueImpose !== null && (!Number.isInteger(masqueImpose) || masqueImpose < 0 || masqueImpose > 7)) throw new RangeError(`encoderQr : masque ${String(masqueImpose)} hors de 0 a 7`);
+	const segment = segmenter(texte);
+	let version = versionMin;
+	while (version <= versionMax) {
+		const utiles = bitsDuSegment(segment, version);
+		if (utiles >= 0 && utiles <= motsDeDonnees(version, correction) * 8) break;
+		version++;
+	}
+	if (version > versionMax) throw new RangeError(`encoderQr : ${String(segment.nombre)} caracteres ne tiennent pas en version ${String(versionMax)} ${correction}`);
+	const bits = new Bits();
+	bits.ajouter(INDICATEUR_DE_MODE[segment.mode], 4);
+	bits.ajouter(segment.nombre, bitsDuCompte(segment.mode, version));
+	bits.concatener(segment.donnees);
+	const capacite = motsDeDonnees(version, correction) * 8;
+	bits.ajouter(0, Math.min(4, capacite - bits.longueur));
+	bits.ajouter(0, (8 - bits.longueur % 8) % 8);
+	for (let remplissage = 236; bits.longueur < capacite; remplissage ^= 253) bits.ajouter(remplissage, 8);
+	const symbole = new Symbole(version, correction);
+	symbole.dessinerLesMotifs();
+	symbole.placerLesMots(entrelacer(bits.octets(), version, correction));
+	symbole.masquer(masqueImpose);
+	return {
+		version,
+		taille: symbole.taille,
+		correction,
+		masque: symbole.masque,
+		modules: symbole.matrice()
+	};
+}
+const NUMERIQUE = /^[0-9]*$/;
+const EN_ALPHANUMERIQUE = /^[0-9A-Z $%*+\-./:]*$/;
+function segmenter(texte) {
+	const donnees = new Bits();
+	if (NUMERIQUE.test(texte)) {
+		for (let i = 0; i < texte.length; i += 3) {
+			const groupe = texte.slice(i, i + 3);
+			donnees.ajouter(Number.parseInt(groupe, 10), groupe.length * 3 + 1);
+		}
+		return {
+			mode: "numerique",
+			nombre: texte.length,
+			donnees
+		};
+	}
+	if (EN_ALPHANUMERIQUE.test(texte)) {
+		const valeur = (i) => ALPHANUMERIQUE.indexOf(texte.charAt(i));
+		for (let i = 0; i + 1 < texte.length; i += 2) donnees.ajouter(valeur(i) * 45 + valeur(i + 1), 11);
+		if (texte.length % 2 === 1) donnees.ajouter(valeur(texte.length - 1), 6);
+		return {
+			mode: "alphanumerique",
+			nombre: texte.length,
+			donnees
+		};
+	}
+	const octets = new TextEncoder().encode(texte);
+	for (const octet of octets) donnees.ajouter(octet, 8);
+	return {
+		mode: "octets",
+		nombre: octets.length,
+		donnees
+	};
+}
+function bitsDuCompte(mode, version) {
+	const [petites, moyennes, grandes] = BITS_DU_COMPTE[mode];
+	return version <= 9 ? petites : version <= 26 ? moyennes : grandes;
+}
+function bitsDuSegment(segment, version) {
+	const bitsDuChamp = bitsDuCompte(segment.mode, version);
+	if (segment.nombre >= 2 ** bitsDuChamp) return -1;
+	return 4 + bitsDuChamp + segment.donnees.longueur;
+}
+function modulesDeDonnees(version) {
+	let resultat = (16 * version + 128) * version + 64;
+	if (version >= 2) {
+		const alignements = Math.floor(version / 7) + 2;
+		resultat -= (25 * alignements - 10) * alignements - 55;
+		if (version >= 7) resultat -= 36;
+	}
+	return resultat;
+}
+function motsDeDonnees(version, correction) {
+	return Math.floor(modulesDeDonnees(version) / 8) - entree(CORRECTION_PAR_BLOC[correction], version) * entree(BLOCS[correction], version);
+}
+function produit(x, y) {
+	let z = 0;
+	for (let i = 7; i >= 0; i--) {
+		z = z << 1 ^ (z >>> 7) * 285;
+		z ^= (y >>> i & 1) * x;
+	}
+	return z;
+}
+function generateur(degre) {
+	const resultat = new Uint8Array(degre);
+	resultat[degre - 1] = 1;
+	let racine = 1;
+	for (let i = 0; i < degre; i++) {
+		for (let j = 0; j < degre; j++) {
+			const suivant = j + 1 < degre ? resultat[j + 1] ?? 0 : 0;
+			resultat[j] = produit(resultat[j] ?? 0, racine) ^ suivant;
+		}
+		racine = produit(racine, 2);
+	}
+	return resultat;
+}
+function reste(donnees, diviseur) {
+	const resultat = new Array(diviseur.length).fill(0);
+	for (const octet of donnees) {
+		const facteur = octet ^ (resultat.shift() ?? 0);
+		resultat.push(0);
+		diviseur.forEach((coefficient, i) => {
+			resultat[i] = (resultat[i] ?? 0) ^ produit(coefficient, facteur);
+		});
+	}
+	return resultat;
+}
+function entrelacer(donnees, version, correction) {
+	const nombreDeBlocs = entree(BLOCS[correction], version);
+	const correctionParBloc = entree(CORRECTION_PAR_BLOC[correction], version);
+	const motsBruts = Math.floor(modulesDeDonnees(version) / 8);
+	const blocsCourts = nombreDeBlocs - motsBruts % nombreDeBlocs;
+	const longueurCourte = Math.floor(motsBruts / nombreDeBlocs);
+	const diviseur = generateur(correctionParBloc);
+	const blocs = [];
+	for (let i = 0, k = 0; i < nombreDeBlocs; i++) {
+		const longueur = longueurCourte - correctionParBloc + (i < blocsCourts ? 0 : 1);
+		const bloc = donnees.slice(k, k + longueur);
+		k += longueur;
+		const code = reste(bloc, diviseur);
+		if (i < blocsCourts) bloc.push(0);
+		blocs.push([...bloc, ...code]);
+	}
+	const resultat = [];
+	for (let i = 0; i <= longueurCourte; i++) blocs.forEach((bloc, j) => {
+		if (i === longueurCourte - correctionParBloc && j < blocsCourts) return;
+		resultat.push(bloc[i] ?? 0);
+	});
+	return resultat;
+}
+var Symbole = class {
+	version;
+	correction;
+	taille;
+	masque = 0;
+	sombres;
+	fonctions;
+	constructor(version, correction) {
+		this.version = version;
+		this.correction = correction;
+		this.taille = version * 4 + 17;
+		this.sombres = new Uint8Array(this.taille * this.taille);
+		this.fonctions = new Uint8Array(this.taille * this.taille);
+	}
+	matrice() {
+		return Array.from({ length: this.taille }, (_, y) => Array.from({ length: this.taille }, (__, x) => this.sombre(x, y)));
+	}
+	dessinerLesMotifs() {
+		for (let i = 0; i < this.taille; i++) {
+			this.poser(6, i, i % 2 === 0);
+			this.poser(i, 6, i % 2 === 0);
+		}
+		this.reperage(3, 3);
+		this.reperage(this.taille - 4, 3);
+		this.reperage(3, this.taille - 4);
+		const positions = this.positionsDAlignement();
+		const dernier = positions.length - 1;
+		positions.forEach((y, i) => {
+			positions.forEach((x, j) => {
+				if (!(i === 0 && j === 0 || i === 0 && j === dernier || i === dernier && j === 0)) this.alignement(x, y);
+			});
+		});
+		this.dessinerLeFormat(0);
+		this.dessinerLaVersion();
+	}
+	placerLesMots(mots) {
+		let i = 0;
+		const total = mots.length * 8;
+		for (let droite = this.taille - 1; droite >= 1; droite -= 2) {
+			if (droite === 6) droite = 5;
+			for (let rang = 0; rang < this.taille; rang++) for (let j = 0; j < 2; j++) {
+				const x = droite - j;
+				const y = (droite + 1 & 2) === 0 ? this.taille - 1 - rang : rang;
+				if (!this.estFonction(x, y) && i < total) {
+					this.ecrire(x, y, ((mots[i >>> 3] ?? 0) >>> 7 - (i & 7) & 1) === 1);
+					i++;
+				}
+			}
+		}
+	}
+	masquer(impose) {
+		let choisi = impose ?? 0;
+		if (impose === null) {
+			let moindre = Number.POSITIVE_INFINITY;
+			for (let masque = 0; masque < 8; masque++) {
+				this.appliquer(masque);
+				this.dessinerLeFormat(masque);
+				const penalite = this.penalite();
+				if (penalite < moindre) {
+					moindre = penalite;
+					choisi = masque;
+				}
+				this.appliquer(masque);
+			}
+		}
+		this.masque = choisi;
+		this.appliquer(choisi);
+		this.dessinerLeFormat(choisi);
+	}
+	sombre(x, y) {
+		return this.sombres[y * this.taille + x] === 1;
+	}
+	estFonction(x, y) {
+		return this.fonctions[y * this.taille + x] === 1;
+	}
+	ecrire(x, y, sombre) {
+		this.sombres[y * this.taille + x] = sombre ? 1 : 0;
+	}
+	poser(x, y, sombre) {
+		this.ecrire(x, y, sombre);
+		this.fonctions[y * this.taille + x] = 1;
+	}
+	reperage(cx, cy) {
+		for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
+			const x = cx + dx;
+			const y = cy + dy;
+			if (x < 0 || x >= this.taille || y < 0 || y >= this.taille) continue;
+			const distance = Math.max(Math.abs(dx), Math.abs(dy));
+			this.poser(x, y, distance !== 2 && distance !== 4);
+		}
+	}
+	alignement(cx, cy) {
+		for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) this.poser(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+	}
+	positionsDAlignement() {
+		if (this.version === 1) return [];
+		const nombre = Math.floor(this.version / 7) + 2;
+		const pas = Math.floor((this.version * 8 + nombre * 3 + 5) / (nombre * 4 - 4)) * 2;
+		const resultat = [6];
+		for (let position = this.taille - 7; resultat.length < nombre; position -= pas) resultat.splice(1, 0, position);
+		return resultat;
+	}
+	dessinerLeFormat(masque) {
+		const donnees = BITS_DU_NIVEAU[this.correction] << 3 | masque;
+		let bch = donnees;
+		for (let i = 0; i < 10; i++) bch = bch << 1 ^ (bch >>> 9) * 1335;
+		const bits = (donnees << 10 | bch) ^ 21522;
+		const bit = (i) => (bits >>> i & 1) === 1;
+		for (let i = 0; i <= 5; i++) this.poser(8, i, bit(i));
+		this.poser(8, 7, bit(6));
+		this.poser(8, 8, bit(7));
+		this.poser(7, 8, bit(8));
+		for (let i = 9; i < 15; i++) this.poser(14 - i, 8, bit(i));
+		for (let i = 0; i < 8; i++) this.poser(this.taille - 1 - i, 8, bit(i));
+		for (let i = 8; i < 15; i++) this.poser(8, this.taille - 15 + i, bit(i));
+		this.poser(8, this.taille - 8, true);
+	}
+	dessinerLaVersion() {
+		if (this.version < 7) return;
+		let bch = this.version;
+		for (let i = 0; i < 12; i++) bch = bch << 1 ^ (bch >>> 11) * 7973;
+		const bits = this.version << 12 | bch;
+		for (let i = 0; i < 18; i++) {
+			const sombre = (bits >>> i & 1) === 1;
+			const a = this.taille - 11 + i % 3;
+			const b = Math.floor(i / 3);
+			this.poser(a, b, sombre);
+			this.poser(b, a, sombre);
+		}
+	}
+	appliquer(masque) {
+		for (let y = 0; y < this.taille; y++) for (let x = 0; x < this.taille; x++) if (!this.estFonction(x, y) && inverse(masque, x, y)) this.ecrire(x, y, !this.sombre(x, y));
+	}
+	penalite() {
+		let resultat = 0;
+		for (let axe = 0; axe < 2; axe++) for (let a = 0; a < this.taille; a++) {
+			const lire = (b) => axe === 0 ? this.sombre(b, a) : this.sombre(a, b);
+			let couleur = false;
+			let longueur = 0;
+			const historique = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let b = 0; b < this.taille; b++) if (lire(b) === couleur) {
+				longueur++;
+				if (longueur === 5) resultat += PENALITE_SUITE;
+				else if (longueur > 5) resultat++;
+			} else {
+				this.ajouterALHistorique(longueur, historique);
+				if (!couleur) resultat += compterLesReperes(historique) * PENALITE_REPERE;
+				couleur = lire(b);
+				longueur = 1;
+			}
+			resultat += this.terminer(couleur, longueur, historique) * PENALITE_REPERE;
+		}
+		for (let y = 0; y < this.taille - 1; y++) for (let x = 0; x < this.taille - 1; x++) {
+			const couleur = this.sombre(x, y);
+			if (couleur === this.sombre(x + 1, y) && couleur === this.sombre(x, y + 1) && couleur === this.sombre(x + 1, y + 1)) resultat += PENALITE_CARRE;
+		}
+		const sombres = this.sombres.reduce((somme, module) => somme + module, 0);
+		const total = this.taille * this.taille;
+		const k = Math.ceil(Math.abs(sombres * 20 - total * 10) / total) - 1;
+		resultat += k * PENALITE_EQUILIBRE;
+		return resultat;
+	}
+	ajouterALHistorique(longueur, historique) {
+		const premiere = historique[0] === 0;
+		historique.pop();
+		historique.unshift(premiere ? longueur + this.taille : longueur);
+	}
+	terminer(couleur, longueur, historique) {
+		let courante = longueur;
+		if (couleur) {
+			this.ajouterALHistorique(courante, historique);
+			courante = 0;
+		}
+		this.ajouterALHistorique(courante + this.taille, historique);
+		return compterLesReperes(historique);
+	}
+};
+function compterLesReperes(historique) {
+	const [avant = 0, n = 0, b = 0, c = 0, d = 0, e = 0, apres = 0] = historique;
+	const coeur = n > 0 && b === n && c === n * 3 && d === n && e === n;
+	return (coeur && avant >= n * 4 && apres >= n ? 1 : 0) + (coeur && apres >= n * 4 && avant >= n ? 1 : 0);
+}
+function inverse(masque, x, y) {
+	switch (masque) {
+		case 0: return (x + y) % 2 === 0;
+		case 1: return y % 2 === 0;
+		case 2: return x % 3 === 0;
+		case 3: return (x + y) % 3 === 0;
+		case 4: return (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+		case 5: return x * y % 2 + x * y % 3 === 0;
+		case 6: return (x * y % 2 + x * y % 3) % 2 === 0;
+		default: return ((x + y) % 2 + x * y % 3) % 2 === 0;
+	}
+}
+var Bits = class {
+	bits = [];
+	get longueur() {
+		return this.bits.length;
+	}
+	ajouter(valeur, nombre) {
+		for (let i = nombre - 1; i >= 0; i--) this.bits.push(valeur >>> i & 1);
+	}
+	concatener(autres) {
+		this.bits.push(...autres.bits);
+	}
+	octets() {
+		const resultat = new Array(Math.ceil(this.bits.length / 8)).fill(0);
+		this.bits.forEach((bit, i) => {
+			resultat[i >>> 3] = (resultat[i >>> 3] ?? 0) | bit << 7 - (i & 7);
+		});
+		return resultat;
+	}
+};
+const ZONE_SILENCIEUSE = 4;
+var StQrCode = class StQrCode {
+	valeur = input.required(...ngDevMode ? [{ debugName: "valeur" }] : 	/* istanbul ignore next */ []);
+	etiquette = input.required(...ngDevMode ? [{ debugName: "etiquette" }] : 	/* istanbul ignore next */ []);
+	taille = input(200, ...ngDevMode ? [{ debugName: "taille" }] : 	/* istanbul ignore next */ []);
+	correction = input("M", ...ngDevMode ? [{ debugName: "correction" }] : 	/* istanbul ignore next */ []);
+	complement = viewChild.required("complement", ...ngDevMode ? [{ debugName: "complement" }] : 	/* istanbul ignore next */ []);
+	matrice = computed(() => {
+		try {
+			return encoderQr(this.valeur(), { correction: this.correction() });
+		} catch (erreur) {
+			if (isDevMode()) console.error("st-qr-code :", erreur);
+			return null;
+		}
+	}, ...ngDevMode ? [{ debugName: "matrice" }] : 	/* istanbul ignore next */ []);
+	cote = computed(() => (this.matrice()?.taille ?? 0) + 2 * ZONE_SILENCIEUSE, ...ngDevMode ? [{ debugName: "cote" }] : 	/* istanbul ignore next */ []);
+	sombres = computed(() => {
+		const matrice = this.matrice();
+		if (matrice === null) return [];
+		const resultat = [];
+		matrice.modules.forEach((ligne, y) => {
+			ligne.forEach((sombre, x) => {
+				if (sombre) resultat.push({
+					x: x + ZONE_SILENCIEUSE,
+					y: y + ZONE_SILENCIEUSE
+				});
+			});
+		});
+		return resultat;
+	}, ...ngDevMode ? [{ debugName: "sombres" }] : 	/* istanbul ignore next */ []);
+	constructor() {
+		afterNextRender(() => {
+			if (!isDevMode()) return;
+			if (this.complement().nativeElement.textContent.trim() === "") console.warn("st-qr-code : aucun [complement] ; un code QR ne se lit ni a l oreille ni sur l ecran qui l affiche, projetez la meme information en texte.");
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.0",
+		ngImport: i0,
+		type: StQrCode,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.0",
+		type: StQrCode,
+		isStandalone: true,
+		selector: "st-qr-code",
+		inputs: {
+			valeur: {
+				classPropertyName: "valeur",
+				publicName: "valeur",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			etiquette: {
+				classPropertyName: "etiquette",
+				publicName: "etiquette",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			taille: {
+				classPropertyName: "taille",
+				publicName: "taille",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			correction: {
+				classPropertyName: "correction",
+				publicName: "correction",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		host: { classAttribute: "st-qr-code" },
+		viewQueries: [{
+			propertyName: "complement",
+			first: true,
+			predicate: ["complement"],
+			descendants: true,
+			isSignal: true
+		}],
+		ngImport: i0,
+		template: "@if (matrice(); as symbole) {\n  <svg\n    class=\"st-qr-code__symbole\"\n    role=\"img\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n    shape-rendering=\"crispEdges\"\n    [attr.aria-label]=\"etiquette()\"\n    [attr.width]=\"taille()\"\n    [attr.height]=\"taille()\"\n    [attr.viewBox]=\"'0 0 ' + cote() + ' ' + cote()\"\n    [attr.data-version]=\"symbole.version\"\n  >\n    <rect class=\"st-qr-code__fond\" x=\"0\" y=\"0\" [attr.width]=\"cote()\" [attr.height]=\"cote()\" />\n    @for (module of sombres(); track $index) {\n      <rect\n        class=\"st-qr-code__module\"\n        [attr.x]=\"module.x\"\n        [attr.y]=\"module.y\"\n        width=\"1\"\n        height=\"1\"\n      />\n    }\n  </svg>\n}\n<div #complement class=\"st-qr-code__complement\"><ng-content select=\"[complement]\" /></div>\n",
+		styles: [".st-vh{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap;border:0}:host([hidden]){display:none!important}:host{display:inline-flex;flex-direction:column;gap:var(--st-espacement-3);align-items:center;max-inline-size:100%}.st-qr-code__symbole{display:block;max-inline-size:100%;block-size:auto;color-scheme:light;color:var(--st-couleur-texte);-webkit-print-color-adjust:exact;print-color-adjust:exact}.st-qr-code__fond{fill:var(--st-couleur-surface)}.st-qr-code__module{fill:currentColor}.st-qr-code__complement{font-size:var(--st-taille-sm);line-height:var(--st-interligne-sm);font-weight:var(--st-graisse-normale);letter-spacing:var(--st-interlettrage-normal);max-inline-size:36ch;overflow-wrap:anywhere;color:var(--st-couleur-texte-discret);text-align:center}.st-qr-code__complement:empty{display:none}\n"],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.0",
+	ngImport: i0,
+	type: StQrCode,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "st-qr-code",
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			host: { class: "st-qr-code" },
+			template: "@if (matrice(); as symbole) {\n  <svg\n    class=\"st-qr-code__symbole\"\n    role=\"img\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n    shape-rendering=\"crispEdges\"\n    [attr.aria-label]=\"etiquette()\"\n    [attr.width]=\"taille()\"\n    [attr.height]=\"taille()\"\n    [attr.viewBox]=\"'0 0 ' + cote() + ' ' + cote()\"\n    [attr.data-version]=\"symbole.version\"\n  >\n    <rect class=\"st-qr-code__fond\" x=\"0\" y=\"0\" [attr.width]=\"cote()\" [attr.height]=\"cote()\" />\n    @for (module of sombres(); track $index) {\n      <rect\n        class=\"st-qr-code__module\"\n        [attr.x]=\"module.x\"\n        [attr.y]=\"module.y\"\n        width=\"1\"\n        height=\"1\"\n      />\n    }\n  </svg>\n}\n<div #complement class=\"st-qr-code__complement\"><ng-content select=\"[complement]\" /></div>\n",
+			styles: [".st-vh{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap;border:0}:host([hidden]){display:none!important}:host{display:inline-flex;flex-direction:column;gap:var(--st-espacement-3);align-items:center;max-inline-size:100%}.st-qr-code__symbole{display:block;max-inline-size:100%;block-size:auto;color-scheme:light;color:var(--st-couleur-texte);-webkit-print-color-adjust:exact;print-color-adjust:exact}.st-qr-code__fond{fill:var(--st-couleur-surface)}.st-qr-code__module{fill:currentColor}.st-qr-code__complement{font-size:var(--st-taille-sm);line-height:var(--st-interligne-sm);font-weight:var(--st-graisse-normale);letter-spacing:var(--st-interlettrage-normal);max-inline-size:36ch;overflow-wrap:anywhere;color:var(--st-couleur-texte-discret);text-align:center}.st-qr-code__complement:empty{display:none}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		valeur: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "valeur",
+				required: true
+			}]
+		}],
+		etiquette: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "etiquette",
+				required: true
+			}]
+		}],
+		taille: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "taille",
+				required: false
+			}]
+		}],
+		correction: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "correction",
+				required: false
+			}]
+		}],
+		complement: [{
+			type: i0.ViewChild,
+			args: ["complement", { isSignal: true }]
+		}]
+	}
+});
+export { StQrCode, encoderQr };
+
+//# sourceMappingURL=starterlib-ui-qr.mjs.map