lintje 0.1.1

package/dist-elements/tag/qr-code.js

@@ -0,0 +1,888 @@
+import { Bt as e, Gt as t, Ht as n, Kt as r, Z as i, zt as a } from "../chunks/base-rBLTcEIv.js";
+import "./toast.js";
+import { t as o } from "../chunks/copied-7BXYVkXT.js";
+//#region src/components/actions/qr-code/qr-code.css?inline
+var s = ":host { display: inline-flex; flex-direction: column; align-items: center; gap: var(--space-3); }\n:host([hidden]) { display: none; }\n\n/* ------------------------------------------------------------------------ */\n\n/* The padding is the code's quiet zone, light in both modes. The square takes the element's\n   width, at least 12.5rem; the image's own size does not count toward it. */\n.lintje-qr-code__zone {\n  width: 100%; min-width: 12.5rem; aspect-ratio: 1;\n  contain: inline-size;\n  padding: var(--space-6);\n  background: var(--color-qr-bg);\n  border: 1px solid var(--color-border-default);\n  forced-color-adjust: none;\n}\n.lintje-qr-code__image { display: block; width: 100%; height: 100%; image-rendering: pixelated; }\n/* Stands where the code would, on the same light zone in both modes. */\n.lintje-qr-code__hint {\n  display: grid; place-items: center; height: 100%; margin: 0;\n  text-align: center; color: var(--color-text-on-light-fill);\n}\n\n/* One cell as wide as the longer label, so the width holds when the label changes. */\n.lintje-qr-code__labels { display: inline-grid; }\n.lintje-qr-code__label { grid-area: 1 / 1; text-align: center; }\n.lintje-qr-code__label.is-hidden { visibility: hidden; }\n", c = class e {
+	static encodeText(t, n) {
+		let r = f.makeSegments(t);
+		return e.encodeSegments(r, n);
+	}
+	static encodeBinary(t, n) {
+		let r = f.makeBytes(t);
+		return e.encodeSegments([r], n);
+	}
+	static encodeSegments(t, n, r = 1, i = 40, a = -1, o = !0) {
+		if (!(e.MIN_VERSION <= r && r <= i && i <= e.MAX_VERSION) || a < -1 || a > 7) throw RangeError("Invalid value");
+		let s, c;
+		for (s = r;; s++) {
+			let r = e.getNumDataCodewords(s, n) * 8, a = f.getTotalBits(t, s);
+			if (a <= r) {
+				c = a;
+				break;
+			}
+			if (s >= i) throw RangeError("Data too long");
+		}
+		for (let t of [
+			e.Ecc.MEDIUM,
+			e.Ecc.QUARTILE,
+			e.Ecc.HIGH
+		]) o && c <= e.getNumDataCodewords(s, t) * 8 && (n = t);
+		let u = [];
+		for (let e of t) {
+			l(e.mode.modeBits, 4, u), l(e.numChars, e.mode.numCharCountBits(s), u);
+			for (let t of e.getData()) u.push(t);
+		}
+		d(u.length == c);
+		let p = e.getNumDataCodewords(s, n) * 8;
+		d(u.length <= p), l(0, Math.min(4, p - u.length), u), l(0, (8 - u.length % 8) % 8, u), d(u.length % 8 == 0);
+		for (let e = 236; u.length < p; e ^= 253) l(e, 8, u);
+		let m = [];
+		for (; m.length * 8 < u.length;) m.push(0);
+		return u.forEach((e, t) => m[t >>> 3] |= e << 7 - (t & 7)), new e(s, n, m, a);
+	}
+	constructor(t, n, r, i) {
+		if (this.version = t, this.errorCorrectionLevel = n, this.modules = [], this.isFunction = [], t < e.MIN_VERSION || t > e.MAX_VERSION) throw RangeError("Version value out of range");
+		if (i < -1 || i > 7) throw RangeError("Mask value out of range");
+		this.size = t * 4 + 17;
+		let a = [];
+		for (let e = 0; e < this.size; e++) a.push(!1);
+		for (let e = 0; e < this.size; e++) this.modules.push(a.slice()), this.isFunction.push(a.slice());
+		this.drawFunctionPatterns();
+		let o = this.addEccAndInterleave(r);
+		if (this.drawCodewords(o), i == -1) {
+			let e = 1e9;
+			for (let t = 0; t < 8; t++) {
+				this.applyMask(t), this.drawFormatBits(t);
+				let n = this.getPenaltyScore();
+				n < e && (i = t, e = n), this.applyMask(t);
+			}
+		}
+		d(0 <= i && i <= 7), this.mask = i, this.applyMask(i), this.drawFormatBits(i), this.isFunction = [];
+	}
+	getModule(e, t) {
+		return 0 <= e && e < this.size && 0 <= t && t < this.size && this.modules[t][e];
+	}
+	drawFunctionPatterns() {
+		for (let e = 0; e < this.size; e++) this.setFunctionModule(6, e, e % 2 == 0), this.setFunctionModule(e, 6, e % 2 == 0);
+		this.drawFinderPattern(3, 3), this.drawFinderPattern(this.size - 4, 3), this.drawFinderPattern(3, this.size - 4);
+		let e = this.getAlignmentPatternPositions(), t = e.length;
+		for (let n = 0; n < t; n++) for (let r = 0; r < t; r++) n == 0 && r == 0 || n == 0 && r == t - 1 || n == t - 1 && r == 0 || this.drawAlignmentPattern(e[n], e[r]);
+		this.drawFormatBits(0), this.drawVersion();
+	}
+	drawFormatBits(e) {
+		let t = this.errorCorrectionLevel.formatBits << 3 | e, n = t;
+		for (let e = 0; e < 10; e++) n = n << 1 ^ (n >>> 9) * 1335;
+		let r = (t << 10 | n) ^ 21522;
+		d(!(r >>> 15));
+		for (let e = 0; e <= 5; e++) this.setFunctionModule(8, e, u(r, e));
+		this.setFunctionModule(8, 7, u(r, 6)), this.setFunctionModule(8, 8, u(r, 7)), this.setFunctionModule(7, 8, u(r, 8));
+		for (let e = 9; e < 15; e++) this.setFunctionModule(14 - e, 8, u(r, e));
+		for (let e = 0; e < 8; e++) this.setFunctionModule(this.size - 1 - e, 8, u(r, e));
+		for (let e = 8; e < 15; e++) this.setFunctionModule(8, this.size - 15 + e, u(r, e));
+		this.setFunctionModule(8, this.size - 8, !0);
+	}
+	drawVersion() {
+		if (this.version < 7) return;
+		let e = this.version;
+		for (let t = 0; t < 12; t++) e = e << 1 ^ (e >>> 11) * 7973;
+		let t = this.version << 12 | e;
+		d(!(t >>> 18));
+		for (let e = 0; e < 18; e++) {
+			let n = u(t, e), r = this.size - 11 + e % 3, i = Math.floor(e / 3);
+			this.setFunctionModule(r, i, n), this.setFunctionModule(i, r, n);
+		}
+	}
+	drawFinderPattern(e, t) {
+		for (let n = -4; n <= 4; n++) for (let r = -4; r <= 4; r++) {
+			let i = Math.max(Math.abs(r), Math.abs(n)), a = e + r, o = t + n;
+			0 <= a && a < this.size && 0 <= o && o < this.size && this.setFunctionModule(a, o, i != 2 && i != 4);
+		}
+	}
+	drawAlignmentPattern(e, t) {
+		for (let n = -2; n <= 2; n++) for (let r = -2; r <= 2; r++) this.setFunctionModule(e + r, t + n, Math.max(Math.abs(r), Math.abs(n)) != 1);
+	}
+	setFunctionModule(e, t, n) {
+		this.modules[t][e] = n, this.isFunction[t][e] = !0;
+	}
+	addEccAndInterleave(t) {
+		let n = this.version, r = this.errorCorrectionLevel;
+		if (t.length != e.getNumDataCodewords(n, r)) throw RangeError("Invalid argument");
+		let i = e.NUM_ERROR_CORRECTION_BLOCKS[r.ordinal][n], a = e.ECC_CODEWORDS_PER_BLOCK[r.ordinal][n], o = Math.floor(e.getNumRawDataModules(n) / 8), s = i - o % i, c = Math.floor(o / i), l = [], u = e.reedSolomonComputeDivisor(a);
+		for (let n = 0, r = 0; n < i; n++) {
+			let i = t.slice(r, r + c - a + (n < s ? 0 : 1));
+			r += i.length;
+			let o = e.reedSolomonComputeRemainder(i, u);
+			n < s && i.push(0), l.push(i.concat(o));
+		}
+		let f = [];
+		for (let e = 0; e < l[0].length; e++) l.forEach((t, n) => {
+			(e != c - a || n >= s) && f.push(t[e]);
+		});
+		return d(f.length == o), f;
+	}
+	drawCodewords(t) {
+		if (t.length != Math.floor(e.getNumRawDataModules(this.version) / 8)) throw RangeError("Invalid argument");
+		let n = 0;
+		for (let e = this.size - 1; e >= 1; e -= 2) {
+			e == 6 && (e = 5);
+			for (let r = 0; r < this.size; r++) for (let i = 0; i < 2; i++) {
+				let a = e - i, o = e + 1 & 2 ? r : this.size - 1 - r;
+				!this.isFunction[o][a] && n < t.length * 8 && (this.modules[o][a] = u(t[n >>> 3], 7 - (n & 7)), n++);
+			}
+		}
+		d(n == t.length * 8);
+	}
+	applyMask(e) {
+		if (e < 0 || e > 7) throw RangeError("Mask value out of range");
+		for (let t = 0; t < this.size; t++) for (let n = 0; n < this.size; n++) {
+			let r;
+			switch (e) {
+				case 0:
+					r = (n + t) % 2 == 0;
+					break;
+				case 1:
+					r = t % 2 == 0;
+					break;
+				case 2:
+					r = n % 3 == 0;
+					break;
+				case 3:
+					r = (n + t) % 3 == 0;
+					break;
+				case 4:
+					r = (Math.floor(n / 3) + Math.floor(t / 2)) % 2 == 0;
+					break;
+				case 5:
+					r = n * t % 2 + n * t % 3 == 0;
+					break;
+				case 6:
+					r = (n * t % 2 + n * t % 3) % 2 == 0;
+					break;
+				case 7:
+					r = ((n + t) % 2 + n * t % 3) % 2 == 0;
+					break;
+				default: throw Error("Unreachable");
+			}
+			!this.isFunction[t][n] && r && (this.modules[t][n] = !this.modules[t][n]);
+		}
+	}
+	getPenaltyScore() {
+		let t = 0;
+		for (let n = 0; n < this.size; n++) {
+			let r = !1, i = 0, a = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let o = 0; o < this.size; o++) this.modules[n][o] == r ? (i++, i == 5 ? t += e.PENALTY_N1 : i > 5 && t++) : (this.finderPenaltyAddHistory(i, a), r || (t += this.finderPenaltyCountPatterns(a) * e.PENALTY_N3), r = this.modules[n][o], i = 1);
+			t += this.finderPenaltyTerminateAndCount(r, i, a) * e.PENALTY_N3;
+		}
+		for (let n = 0; n < this.size; n++) {
+			let r = !1, i = 0, a = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let o = 0; o < this.size; o++) this.modules[o][n] == r ? (i++, i == 5 ? t += e.PENALTY_N1 : i > 5 && t++) : (this.finderPenaltyAddHistory(i, a), r || (t += this.finderPenaltyCountPatterns(a) * e.PENALTY_N3), r = this.modules[o][n], i = 1);
+			t += this.finderPenaltyTerminateAndCount(r, i, a) * e.PENALTY_N3;
+		}
+		for (let n = 0; n < this.size - 1; n++) for (let r = 0; r < this.size - 1; r++) {
+			let i = this.modules[n][r];
+			i == this.modules[n][r + 1] && i == this.modules[n + 1][r] && i == this.modules[n + 1][r + 1] && (t += e.PENALTY_N2);
+		}
+		let n = 0;
+		for (let e of this.modules) n = e.reduce((e, t) => e + +!!t, n);
+		let r = this.size * this.size, i = Math.ceil(Math.abs(n * 20 - r * 10) / r) - 1;
+		return d(0 <= i && i <= 9), t += i * e.PENALTY_N4, d(0 <= t && t <= 2568888), t;
+	}
+	getAlignmentPatternPositions() {
+		if (this.version == 1) return [];
+		{
+			let e = Math.floor(this.version / 7) + 2, t = Math.floor((this.version * 8 + e * 3 + 5) / (e * 4 - 4)) * 2, n = [6];
+			for (let r = this.size - 7; n.length < e; r -= t) n.splice(1, 0, r);
+			return n;
+		}
+	}
+	static getNumRawDataModules(t) {
+		if (t < e.MIN_VERSION || t > e.MAX_VERSION) throw RangeError("Version number out of range");
+		let n = (16 * t + 128) * t + 64;
+		if (t >= 2) {
+			let e = Math.floor(t / 7) + 2;
+			n -= (25 * e - 10) * e - 55, t >= 7 && (n -= 36);
+		}
+		return d(208 <= n && n <= 29648), n;
+	}
+	static getNumDataCodewords(t, n) {
+		return Math.floor(e.getNumRawDataModules(t) / 8) - e.ECC_CODEWORDS_PER_BLOCK[n.ordinal][t] * e.NUM_ERROR_CORRECTION_BLOCKS[n.ordinal][t];
+	}
+	static reedSolomonComputeDivisor(t) {
+		if (t < 1 || t > 255) throw RangeError("Degree out of range");
+		let n = [];
+		for (let e = 0; e < t - 1; e++) n.push(0);
+		n.push(1);
+		let r = 1;
+		for (let i = 0; i < t; i++) {
+			for (let t = 0; t < n.length; t++) n[t] = e.reedSolomonMultiply(n[t], r), t + 1 < n.length && (n[t] ^= n[t + 1]);
+			r = e.reedSolomonMultiply(r, 2);
+		}
+		return n;
+	}
+	static reedSolomonComputeRemainder(t, n) {
+		let r = n.map((e) => 0);
+		for (let i of t) {
+			let t = i ^ r.shift();
+			r.push(0), n.forEach((n, i) => r[i] ^= e.reedSolomonMultiply(n, t));
+		}
+		return r;
+	}
+	static reedSolomonMultiply(e, t) {
+		if (e >>> 8 || t >>> 8) throw RangeError("Byte out of range");
+		let n = 0;
+		for (let r = 7; r >= 0; r--) n = n << 1 ^ (n >>> 7) * 285, n ^= (t >>> r & 1) * e;
+		return d(!(n >>> 8)), n;
+	}
+	finderPenaltyCountPatterns(e) {
+		let t = e[1];
+		d(t <= this.size * 3);
+		let n = t > 0 && e[2] == t && e[3] == t * 3 && e[4] == t && e[5] == t;
+		return (n && e[0] >= t * 4 && e[6] >= t ? 1 : 0) + (n && e[6] >= t * 4 && e[0] >= t ? 1 : 0);
+	}
+	finderPenaltyTerminateAndCount(e, t, n) {
+		return e && (this.finderPenaltyAddHistory(t, n), t = 0), t += this.size, this.finderPenaltyAddHistory(t, n), this.finderPenaltyCountPatterns(n);
+	}
+	finderPenaltyAddHistory(e, t) {
+		t[0] == 0 && (e += this.size), t.pop(), t.unshift(e);
+	}
+	static {
+		this.MIN_VERSION = 1;
+	}
+	static {
+		this.MAX_VERSION = 40;
+	}
+	static {
+		this.PENALTY_N1 = 3;
+	}
+	static {
+		this.PENALTY_N2 = 3;
+	}
+	static {
+		this.PENALTY_N3 = 40;
+	}
+	static {
+		this.PENALTY_N4 = 10;
+	}
+	static {
+		this.ECC_CODEWORDS_PER_BLOCK = [
+			[
+				-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
+			],
+			[
+				-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
+			],
+			[
+				-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
+			],
+			[
+				-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
+			]
+		];
+	}
+	static {
+		this.NUM_ERROR_CORRECTION_BLOCKS = [
+			[
+				-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
+			],
+			[
+				-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
+			],
+			[
+				-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
+			],
+			[
+				-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
+			]
+		];
+	}
+};
+function l(e, t, n) {
+	if (t < 0 || t > 31 || e >>> t) throw RangeError("Value out of range");
+	for (let r = t - 1; r >= 0; r--) n.push(e >>> r & 1);
+}
+function u(e, t) {
+	return !!(e >>> t & 1);
+}
+function d(e) {
+	if (!e) throw Error("Assertion error");
+}
+var f = class e {
+	static makeBytes(t) {
+		let n = [];
+		for (let e of t) l(e, 8, n);
+		return new e(e.Mode.BYTE, t.length, n);
+	}
+	static makeNumeric(t) {
+		if (!e.isNumeric(t)) throw RangeError("String contains non-numeric characters");
+		let n = [];
+		for (let e = 0; e < t.length;) {
+			let r = Math.min(t.length - e, 3);
+			l(parseInt(t.substring(e, e + r), 10), r * 3 + 1, n), e += r;
+		}
+		return new e(e.Mode.NUMERIC, t.length, n);
+	}
+	static makeAlphanumeric(t) {
+		if (!e.isAlphanumeric(t)) throw RangeError("String contains unencodable characters in alphanumeric mode");
+		let n = [], r = 0;
+		for (; r + 2 <= t.length; r += 2) {
+			let i = e.ALPHANUMERIC_CHARSET.indexOf(t.charAt(r)) * 45;
+			i += e.ALPHANUMERIC_CHARSET.indexOf(t.charAt(r + 1)), l(i, 11, n);
+		}
+		return r < t.length && l(e.ALPHANUMERIC_CHARSET.indexOf(t.charAt(r)), 6, n), new e(e.Mode.ALPHANUMERIC, t.length, n);
+	}
+	static makeSegments(t) {
+		return t == "" ? [] : e.isNumeric(t) ? [e.makeNumeric(t)] : e.isAlphanumeric(t) ? [e.makeAlphanumeric(t)] : [e.makeBytes(e.toUtf8ByteArray(t))];
+	}
+	static makeEci(t) {
+		let n = [];
+		if (t < 0) throw RangeError("ECI assignment value out of range");
+		if (t < 128) l(t, 8, n);
+		else if (t < 16384) l(2, 2, n), l(t, 14, n);
+		else if (t < 1e6) l(6, 3, n), l(t, 21, n);
+		else throw RangeError("ECI assignment value out of range");
+		return new e(e.Mode.ECI, 0, n);
+	}
+	static isNumeric(t) {
+		return e.NUMERIC_REGEX.test(t);
+	}
+	static isAlphanumeric(t) {
+		return e.ALPHANUMERIC_REGEX.test(t);
+	}
+	constructor(e, t, n) {
+		if (this.mode = e, this.numChars = t, this.bitData = n, t < 0) throw RangeError("Invalid argument");
+		this.bitData = n.slice();
+	}
+	getData() {
+		return this.bitData.slice();
+	}
+	static getTotalBits(e, t) {
+		let n = 0;
+		for (let r of e) {
+			let e = r.mode.numCharCountBits(t);
+			if (r.numChars >= 1 << e) return Infinity;
+			n += 4 + e + r.bitData.length;
+		}
+		return n;
+	}
+	static toUtf8ByteArray(e) {
+		e = encodeURI(e);
+		let t = [];
+		for (let n = 0; n < e.length; n++) e.charAt(n) == "%" ? (t.push(parseInt(e.substring(n + 1, n + 3), 16)), n += 2) : t.push(e.charCodeAt(n));
+		return t;
+	}
+	static {
+		this.NUMERIC_REGEX = /^[0-9]*$/;
+	}
+	static {
+		this.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
+	}
+	static {
+		this.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+	}
+};
+(function(e) {
+	class t {
+		static {
+			this.LOW = new t(0, 1);
+		}
+		static {
+			this.MEDIUM = new t(1, 0);
+		}
+		static {
+			this.QUARTILE = new t(2, 3);
+		}
+		static {
+			this.HIGH = new t(3, 2);
+		}
+		constructor(e, t) {
+			this.ordinal = e, this.formatBits = t;
+		}
+	}
+	e.Ecc = t;
+})(c ||= {}), (function(e) {
+	class t {
+		static {
+			this.NUMERIC = new t(1, [
+				10,
+				12,
+				14
+			]);
+		}
+		static {
+			this.ALPHANUMERIC = new t(2, [
+				9,
+				11,
+				13
+			]);
+		}
+		static {
+			this.BYTE = new t(4, [
+				8,
+				16,
+				16
+			]);
+		}
+		static {
+			this.KANJI = new t(8, [
+				8,
+				10,
+				12
+			]);
+		}
+		static {
+			this.ECI = new t(7, [
+				0,
+				0,
+				0
+			]);
+		}
+		constructor(e, t) {
+			this.modeBits = e, this.numBitsCharCount = t;
+		}
+		numCharCountBits(e) {
+			return this.numBitsCharCount[Math.floor((e + 7) / 17)];
+		}
+	}
+	e.Mode = t;
+})(f ||= {});
+//#endregion
+//#region src/components/actions/qr-code/qr-code.ts
+var p = "Kopieer als afbeelding", m = "Afbeelding gekopieerd", h = "Kopiëren is niet gelukt. Maak een schermafbeelding van de QR-code.", g = "Deze link is te lang voor een QR-code.", _ = 480, v = .14;
+function y(e, t) {
+	let n = c.encodeText(e, c.Ecc.LOW), r = "";
+	for (let e = 0; e < n.size; e++) for (let t = 0; t < n.size; t++) {
+		if (!n.getModule(t, e)) continue;
+		let i = t;
+		for (; t + 1 < n.size && n.getModule(t + 1, e);) t++;
+		r += `M${i} ${e}h${t - i + 1}v1H${i}z`;
+	}
+	let i = t ? ` fill="${t}"` : "", a = `<svg xmlns="http://www.w3.org/2000/svg" width="${n.size}" height="${n.size}" viewBox="0 0 ${n.size} ${n.size}" shape-rendering="crispEdges"><path${i} d="${r}"/></svg>`;
+	return `data:image/svg+xml,${encodeURIComponent(a)}`;
+}
+var b = class extends a {
+	constructor(...e) {
+		super(...e), this.src = "", this.value = "", this.copied = !1, this.failed = !1, this.status = "", this.made = "", this.tooLong = !1;
+	}
+	static {
+		this.styles = n(s);
+	}
+	static {
+		this.properties = {
+			src: { type: String },
+			value: { type: String },
+			label: { type: String },
+			made: { state: !0 },
+			tooLong: { state: !0 },
+			copied: { state: !0 },
+			failed: { state: !0 },
+			status: { state: !0 }
+		};
+	}
+	get drawn() {
+		return this.src || this.made;
+	}
+	willUpdate(e) {
+		if (e.has("value") && (this.made = "", this.tooLong = !1, this.value)) try {
+			let e = getComputedStyle(this).getPropertyValue("--color-qr-fg").trim();
+			this.made = y(this.value, e);
+		} catch (e) {
+			if (!(e instanceof RangeError)) throw e;
+			this.tooLong = !0;
+		}
+	}
+	disconnectedCallback() {
+		clearTimeout(this.timer), clearTimeout(this.gap), super.disconnectedCallback();
+	}
+	async image() {
+		let e = new Image();
+		e.src = this.drawn, await e.decode();
+		let t = Math.round(_ * v), n = document.createElement("canvas");
+		n.width = n.height = 614;
+		let r = n.getContext("2d");
+		if (!r) throw Error("no canvas");
+		return r.fillStyle = getComputedStyle(this).getPropertyValue("--color-qr-bg").trim(), r.fillRect(0, 0, n.width, n.height), r.imageSmoothingEnabled = !1, r.drawImage(e, t, t, _, _), new Promise((e, t) => n.toBlob((n) => n ? e(n) : t(/* @__PURE__ */ Error("no image")), "image/png"));
+	}
+	async copy() {
+		if (this.drawn) {
+			try {
+				if (!navigator.clipboard?.write || typeof ClipboardItem > "u") throw Error("no clipboard");
+				await navigator.clipboard.write([new ClipboardItem({ "image/png": this.image() })]);
+			} catch {
+				this.failed = !0, this.emit("lintje-copy-error");
+				return;
+			}
+			this.failed = !1, this.copied = !0, clearTimeout(this.timer), clearTimeout(this.gap), this.timer = setTimeout(() => {
+				this.copied = !1, this.status = "";
+			}, o), this.status === m ? (this.status = "", this.gap = setTimeout(() => this.status = m, 100)) : this.status = m, this.emit("lintje-copy");
+		}
+	}
+	get alt() {
+		return this.label ? this.label : this.value ? `QR-code: ${this.value}` : "QR-code";
+	}
+	onToastClose(e) {
+		e.stopPropagation(), this.failed = !1;
+	}
+	render() {
+		return r`<div class="lintje-qr-code__zone">
+        ${this.drawn ? r`<img class="lintje-qr-code__image" src=${this.drawn} alt=${this.alt} />` : this.tooLong ? r`<p class="lintje-qr-code__hint">${g}</p>` : t}
+      </div>
+      <lintje-button
+        variant="secondary"
+        icon=${this.copied ? "functioneel-vinkje" : "functioneel-kopieren"}
+        ?disabled=${!this.drawn}
+        @click=${this.copy}
+        ><span class="lintje-qr-code__labels"
+          ><span class=${i({
+			"lintje-qr-code__label": !0,
+			"is-hidden": this.copied
+		})}
+            >${p}</span
+          ><span class=${i({
+			"lintje-qr-code__label": !0,
+			"is-hidden": !this.copied
+		})}
+            >${m}</span
+          ></span
+        ></lintje-button
+      ><span class="visually-hidden" role="status">${this.status || t}</span>${this.failed ? r`<lintje-toast kind="error" @lintje-close=${this.onToastClose}>${h}</lintje-toast>` : t}`;
+	}
+};
+e("lintje-qr-code", b);
+//#endregion
+export { b as LintjeQrCode, y as codeImage };