@vizejs/ui 0.426.3 → 0.428.0

package/dist/qr-code-BGbc3Mxp.mjs

@@ -0,0 +1,1420 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, toDisplayString, useTemplateRef } from "vue";
+//#region src/families/media/qr-code/qr-code-error.ts
+/** Typed encoder diagnostic. `message` starts with the stable {@link code}. */
+var QrCodeEncodeError = class extends Error {
+	/** Stable machine-readable diagnostic code. */
+	code;
+	constructor(code, detail) {
+		super(`${code}: ${detail}`);
+		this.name = "QrCodeEncodeError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/families/media/qr-code/qr-code-tables.ts
+/** Error correction levels from weakest to strongest. */
+const QR_CODE_ERROR_CORRECTION_LEVELS = Object.freeze([
+	"L",
+	"M",
+	"Q",
+	"H"
+]);
+const ECC_INDEX = Object.freeze({
+	L: 0,
+	M: 1,
+	Q: 2,
+	H: 3
+});
+/** Two-bit format field value for each level (ISO/IEC 18004 table 12). */
+const QR_CODE_FORMAT_BITS = Object.freeze({
+	L: 1,
+	M: 0,
+	Q: 3,
+	H: 2
+});
+const 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
+	]
+];
+const 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
+	]
+];
+/** Mode indicator nibble for each supported mode. */
+const QR_CODE_MODE_INDICATOR = Object.freeze({
+	numeric: 1,
+	alphanumeric: 2,
+	byte: 4,
+	kanji: 8
+});
+const CHARACTER_COUNT_BITS = Object.freeze({
+	numeric: [
+		10,
+		12,
+		14
+	],
+	alphanumeric: [
+		9,
+		11,
+		13
+	],
+	byte: [
+		8,
+		16,
+		16
+	],
+	kanji: [
+		8,
+		10,
+		12
+	]
+});
+function tableValue(table, ecc, version) {
+	return table[ECC_INDEX[ecc]]?.[version] ?? 0;
+}
+/** Error correction codewords in each block. */
+function eccCodewordsPerBlock(version, ecc) {
+	return tableValue(ECC_CODEWORDS_PER_BLOCK, ecc, version);
+}
+/** Number of error correction blocks the codewords are split into. */
+function errorCorrectionBlockCount(version, ecc) {
+	return tableValue(ERROR_CORRECTION_BLOCKS, ecc, version);
+}
+/** Modules per side for a version. */
+function qrCodeSizeOf(version) {
+	return version * 4 + 17;
+}
+/**
+* Data and error correction modules available after function patterns,
+* including remainder bits.
+*/
+function rawDataModuleCount(version) {
+	let result = (16 * version + 128) * version + 64;
+	if (version >= 2) {
+		const alignmentCount = Math.floor(version / 7) + 2;
+		result -= (25 * alignmentCount - 10) * alignmentCount - 55;
+		if (version >= 7) result -= 36;
+	}
+	return result;
+}
+/** 8-bit data codewords available for a version and level. */
+function dataCodewordCount(version, ecc) {
+	return Math.floor(rawDataModuleCount(version) / 8) - eccCodewordsPerBlock(version, ecc) * errorCorrectionBlockCount(version, ecc);
+}
+/** Character count indicator width for a mode at a version. */
+function characterCountBits(mode, version) {
+	return CHARACTER_COUNT_BITS[mode][version <= 9 ? 0 : version <= 26 ? 1 : 2];
+}
+/** Center coordinates of alignment patterns on each axis, in ascending order. */
+function alignmentPatternPositions(version) {
+	if (version === 1) return [];
+	const count = Math.floor(version / 7) + 2;
+	const step = Math.floor((version * 8 + count * 3 + 5) / (count * 4 - 4)) * 2;
+	const positions = [6];
+	for (let position = qrCodeSizeOf(version) - 7; positions.length < count; position -= step) positions.splice(1, 0, position);
+	return positions;
+}
+//#endregion
+//#region src/families/media/qr-code/qr-code-segments.ts
+const ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+const MAX_ECI_DESIGNATOR = 999999;
+/** Append `length` low bits of `value`, most significant first. */
+function appendBits(target, value, length) {
+	for (let index = length - 1; index >= 0; index--) target.push(value >>> index & 1);
+}
+function isDigit(codePoint) {
+	return codePoint >= 48 && codePoint <= 57;
+}
+function alphanumericIndex(codePoint) {
+	return codePoint < 128 ? ALPHANUMERIC_CHARSET.indexOf(String.fromCharCode(codePoint)) : -1;
+}
+function utf8Length(codePoint) {
+	if (codePoint < 128) return 1;
+	if (codePoint < 2048) return 2;
+	return codePoint < 65536 ? 3 : 4;
+}
+function freezeSegment(mode, count, bits) {
+	return Object.freeze({
+		mode,
+		count,
+		bits: Object.freeze(bits)
+	});
+}
+/**
+* Numeric segment: digit groups of three packed into 10 bits (7 or 4 bits for a tail).
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_MODE` for non-digits.
+*/
+function createQrCodeNumericSegment(digits) {
+	const bits = [];
+	for (const character of digits) if (!isDigit(character.charCodeAt(0))) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_MODE", "numeric mode accepts only digits");
+	for (let index = 0; index < digits.length; index += 3) {
+		const chunk = digits.slice(index, index + 3);
+		appendBits(bits, Number.parseInt(chunk, 10), chunk.length * 3 + 1);
+	}
+	return freezeSegment("numeric", digits.length, bits);
+}
+/**
+* Alphanumeric segment: character pairs packed into 11 bits (6 bits for a tail).
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_MODE` outside `0-9A-Z $%*+-./:`.
+*/
+function createQrCodeAlphanumericSegment(text) {
+	const values = [];
+	for (const character of text) {
+		const value = alphanumericIndex(character.codePointAt(0) ?? 0);
+		if (value < 0) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_MODE", "alphanumeric mode accepts only 0-9, A-Z, space, and $%*+-./:");
+		values.push(value);
+	}
+	const bits = [];
+	let index = 0;
+	for (; index + 1 < values.length; index += 2) appendBits(bits, (values[index] ?? 0) * 45 + (values[index + 1] ?? 0), 11);
+	if (index < values.length) appendBits(bits, values[index] ?? 0, 6);
+	return freezeSegment("alphanumeric", values.length, bits);
+}
+/** Byte segment. Text is UTF-8 encoded; bytes are used as-is. */
+function createQrCodeByteSegment(data) {
+	const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+	const bits = [];
+	for (const byte of bytes) appendBits(bits, byte, 8);
+	return freezeSegment("byte", bytes.length, bits);
+}
+/**
+* Kanji segment: each Shift_JIS double-byte character packed into 13 bits.
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_MODE` for characters the
+* encoder cannot map into the QR Kanji ranges.
+*/
+function createQrCodeKanjiSegment(text, kanji) {
+	const bits = [];
+	let count = 0;
+	for (const character of text) {
+		const value = kanjiValue(kanji, character.codePointAt(0) ?? 0);
+		if (value === void 0) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_MODE", "kanji mode accepts only Shift_JIS double-byte characters in 0x8140-0x9FFC or 0xE040-0xEBBF");
+		appendBits(bits, value, 13);
+		count++;
+	}
+	return freezeSegment("kanji", count, bits);
+}
+/**
+* ECI header segment switching the interpretation of following byte data,
+* e.g. `26` for UTF-8. Designators use 8, 16, or 24 bits by magnitude.
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_OPTION` outside `0..999999`.
+*/
+function createQrCodeEciSegment(designator) {
+	if (!Number.isInteger(designator) || designator < 0 || designator > MAX_ECI_DESIGNATOR) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "eci must be an integer in 0..999999");
+	const bits = [];
+	if (designator < 128) appendBits(bits, designator, 8);
+	else if (designator < 16384) {
+		appendBits(bits, 2, 2);
+		appendBits(bits, designator, 14);
+	} else {
+		appendBits(bits, 6, 3);
+		appendBits(bits, designator, 21);
+	}
+	return freezeSegment("eci", 0, bits);
+}
+/** 13-bit QR Kanji value for a code point, or `undefined`. */
+function kanjiValue(kanji, codePoint) {
+	const code = kanji.toShiftJis(codePoint);
+	if (code === void 0) return void 0;
+	let offset;
+	if (code >= 33088 && code <= 40956) offset = code - 33088;
+	else if (code >= 57408 && code <= 60351) offset = code - 49472;
+	else return void 0;
+	const low = offset & 255;
+	return low <= 188 ? (offset >>> 8) * 192 + low : void 0;
+}
+/**
+* Total bits for segments at a version, or `Infinity` when a count overflows
+* its indicator.
+*/
+function qrCodeSegmentBitLength(segments, version) {
+	let total = 0;
+	for (const segment of segments) {
+		if (segment.mode === "eci") {
+			total += 4 + segment.bits.length;
+			continue;
+		}
+		const countBits = characterCountBits(segment.mode, version);
+		if (segment.count >= 2 ** countBits) return Number.POSITIVE_INFINITY;
+		total += 4 + countBits + segment.bits.length;
+	}
+	return total;
+}
+function codePointsOf(text) {
+	const result = [];
+	for (const character of text) result.push(character.codePointAt(0) ?? 0);
+	return result;
+}
+function singleMode(codePoints, kanji) {
+	if (codePoints.every(isDigit)) return "numeric";
+	if (codePoints.every((codePoint) => alphanumericIndex(codePoint) >= 0)) return "alphanumeric";
+	if (kanji && codePoints.every((codePoint) => kanjiValue(kanji, codePoint) !== void 0)) return "kanji";
+	return "byte";
+}
+function segmentFor(mode, text, kanji) {
+	switch (mode) {
+		case "numeric": return createQrCodeNumericSegment(text);
+		case "alphanumeric": return createQrCodeAlphanumericSegment(text);
+		case "byte": return createQrCodeByteSegment(text);
+		case "kanji":
+			if (kanji === void 0) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_MODE", "kanji mode requires a kanji encoder such as qrCodeKanjiEncoder");
+			return createQrCodeKanjiSegment(text, kanji);
+	}
+}
+const OPTIMAL_MODES = [
+	"byte",
+	"alphanumeric",
+	"numeric",
+	"kanji"
+];
+/**
+* Per-character modes minimizing total bits at a version (Project Nayuki's
+* dynamic program). Costs are in sixths of a bit so numeric (10/3 bits) and
+* alphanumeric (11/2 bits) characters stay integral; partial bits round up
+* when a segment ends, which makes the fractional accounting exact.
+*/
+function optimalCharacterModes(codePoints, version, kanji) {
+	const count = OPTIMAL_MODES.length;
+	const headCosts = OPTIMAL_MODES.map((mode) => (4 + characterCountBits(mode, version)) * 6);
+	const transitions = [];
+	let previous = headCosts.slice();
+	for (const codePoint of codePoints) {
+		const costs = Array.from({ length: count }).fill(Number.POSITIVE_INFINITY);
+		const from = Array.from({ length: count }).fill(null);
+		costs[0] = (previous[0] ?? 0) + utf8Length(codePoint) * 8 * 6;
+		from[0] = "byte";
+		if (alphanumericIndex(codePoint) >= 0) {
+			costs[1] = (previous[1] ?? 0) + 33;
+			from[1] = "alphanumeric";
+		}
+		if (isDigit(codePoint)) {
+			costs[2] = (previous[2] ?? 0) + 20;
+			from[2] = "numeric";
+		}
+		if (kanji && kanjiValue(kanji, codePoint) !== void 0) {
+			costs[3] = (previous[3] ?? 0) + 78;
+			from[3] = "kanji";
+		}
+		const extended = costs.slice();
+		const representable = from.map((entry) => entry !== null);
+		for (let to = 0; to < count; to++) for (let fromIndex = 0; fromIndex < count; fromIndex++) {
+			if (representable[fromIndex] !== true) continue;
+			const switched = Math.ceil((extended[fromIndex] ?? 0) / 6) * 6 + (headCosts[to] ?? 0);
+			if (from[to] === null || switched < (costs[to] ?? 0)) {
+				costs[to] = switched;
+				from[to] = OPTIMAL_MODES[fromIndex] ?? "byte";
+			}
+		}
+		transitions.push(from);
+		previous = costs;
+	}
+	let mode = "byte";
+	let lowest = Number.POSITIVE_INFINITY;
+	previous.forEach((cost, index) => {
+		if (cost < lowest) {
+			lowest = cost;
+			mode = OPTIMAL_MODES[index] ?? "byte";
+		}
+	});
+	const result = Array.from({ length: codePoints.length });
+	for (let index = codePoints.length - 1; index >= 0; index--) {
+		mode = transitions[index]?.[OPTIMAL_MODES.indexOf(mode)] ?? "byte";
+		result[index] = mode;
+	}
+	return result;
+}
+/**
+* Split text into encoded segments.
+*
+* `mode` forces one segment in that mode. Otherwise `segmentation: "single"`
+* picks the most compact single mode (numeric, alphanumeric, kanji, then
+* UTF-8 bytes) and `"optimal"` mixes modes to minimize the bit length at
+* `version`. Byte values always produce one byte segment.
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_MODE` when a forced mode
+* cannot represent the value.
+*/
+function createQrCodeSegments(value, options = {}) {
+	const mode = options.mode ?? "auto";
+	if (typeof value !== "string") {
+		if (mode !== "auto" && mode !== "byte") throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_MODE", `binary values can only use byte mode, not ${mode}`);
+		return Object.freeze(value.length === 0 ? [] : [createQrCodeByteSegment(value)]);
+	}
+	if (value.length === 0) return Object.freeze([]);
+	if (mode !== "auto") return Object.freeze([segmentFor(mode, value, options.kanji)]);
+	const codePoints = codePointsOf(value);
+	if ((options.segmentation ?? "optimal") === "single") return Object.freeze([segmentFor(singleMode(codePoints, options.kanji), value, options.kanji)]);
+	const modes = optimalCharacterModes(codePoints, options.version ?? 1, options.kanji);
+	const segments = [];
+	let start = 0;
+	const characters = Array.from(value);
+	for (let index = 1; index <= characters.length; index++) {
+		if (index < characters.length && modes[index] === modes[start]) continue;
+		const text = characters.slice(start, index).join("");
+		segments.push(segmentFor(modes[start] ?? "byte", text, options.kanji));
+		start = index;
+	}
+	return Object.freeze(segments);
+}
+//#endregion
+//#region src/families/media/qr-code/qr-code-encoder.ts
+const MASKS = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
+];
+const UTF8_ECI = 26;
+function isVersion(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 40;
+}
+function isMask(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 7;
+}
+/** Multiply two elements of GF(2^8) modulo the QR polynomial `x^8 + x^4 + x^3 + x^2 + 1`. */
+function gf256Multiply(left, right) {
+	let result = 0;
+	for (let bit = 7; bit >= 0; bit--) {
+		result = result << 1 ^ (result >>> 7) * 285;
+		result ^= (right >>> bit & 1) * left;
+	}
+	return result & 255;
+}
+/**
+* Reed–Solomon generator polynomial coefficients for a degree, highest term
+* first with the implicit leading `1` omitted.
+*/
+function reedSolomonGenerator(degree) {
+	if (!Number.isInteger(degree) || degree < 1 || degree > 255) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "degree must be in 1..255");
+	const result = Array.from({ length: degree }).fill(0);
+	result[degree - 1] = 1;
+	let root = 1;
+	for (let index = 0; index < degree; index++) {
+		for (let term = 0; term < result.length; term++) {
+			const next = term + 1 < result.length ? result[term + 1] ?? 0 : 0;
+			result[term] = gf256Multiply(result[term] ?? 0, root) ^ next;
+		}
+		root = gf256Multiply(root, 2);
+	}
+	return result;
+}
+/** Reed–Solomon error correction codewords for data under a generator. */
+function reedSolomonRemainder(data, generator) {
+	const result = Array.from({ length: generator.length }).fill(0);
+	for (const byte of data) {
+		const factor = byte ^ (result.shift() ?? 0);
+		result.push(0);
+		for (let index = 0; index < generator.length; index++) result[index] = (result[index] ?? 0) ^ gf256Multiply(generator[index] ?? 0, factor);
+	}
+	return result;
+}
+/**
+* Build the padded data codewords for segments at a version and level.
+* Exposed for conformance tests against the standard's worked examples.
+*/
+function createDataCodewords(segments, version, ecc) {
+	const bits = [];
+	for (const segment of segments) {
+		if (segment.mode === "eci") appendBits(bits, 7, 4);
+		else {
+			appendBits(bits, QR_CODE_MODE_INDICATOR[segment.mode], 4);
+			appendBits(bits, segment.count, characterCountBits(segment.mode, version));
+		}
+		for (const bit of segment.bits) bits.push(bit);
+	}
+	const capacityBits = dataCodewordCount(version, ecc) * 8;
+	appendBits(bits, 0, Math.min(4, capacityBits - bits.length));
+	appendBits(bits, 0, (8 - bits.length % 8) % 8);
+	for (let pad = 236; bits.length < capacityBits; pad ^= 253) appendBits(bits, pad, 8);
+	const codewords = [];
+	for (let index = 0; index < bits.length; index += 8) {
+		let byte = 0;
+		for (let offset = 0; offset < 8; offset++) byte = byte << 1 | (bits[index + offset] ?? 0);
+		codewords.push(byte);
+	}
+	return codewords;
+}
+/** Split data into blocks, append Reed–Solomon codewords, and interleave. */
+function addErrorCorrectionAndInterleave(data, version, ecc) {
+	const blockCount = errorCorrectionBlockCount(version, ecc);
+	const blockEccLength = eccCodewordsPerBlock(version, ecc);
+	const rawCodewords = Math.floor(rawDataModuleCount(version) / 8);
+	const shortBlockCount = blockCount - rawCodewords % blockCount;
+	const shortBlockLength = Math.floor(rawCodewords / blockCount);
+	const generator = reedSolomonGenerator(blockEccLength);
+	const blocks = [];
+	let offset = 0;
+	for (let index = 0; index < blockCount; index++) {
+		const length = shortBlockLength - blockEccLength + (index < shortBlockCount ? 0 : 1);
+		const block = data.slice(offset, offset + length);
+		offset += length;
+		const remainder = reedSolomonRemainder(block, generator);
+		if (index < shortBlockCount) block.push(0);
+		blocks.push([...block, ...remainder]);
+	}
+	const result = [];
+	const blockLength = blocks[0]?.length ?? 0;
+	for (let column = 0; column < blockLength; column++) blocks.forEach((block, blockIndex) => {
+		if (column !== shortBlockLength - blockEccLength || blockIndex >= shortBlockCount) result.push(block[column] ?? 0);
+	});
+	return result;
+}
+/** 15-bit format information (level + mask with BCH code and XOR mask). */
+function formatInformationBits(ecc, mask) {
+	const data = QR_CODE_FORMAT_BITS[ecc] << 3 | mask;
+	let remainder = data;
+	for (let index = 0; index < 10; index++) remainder = remainder << 1 ^ (remainder >>> 9) * 1335;
+	return (data << 10 | remainder) ^ 21522;
+}
+/** 18-bit version information for versions 7 and above. */
+function versionInformationBits(version) {
+	let remainder = version;
+	for (let index = 0; index < 12; index++) remainder = remainder << 1 ^ (remainder >>> 11) * 7973;
+	return version << 12 | remainder;
+}
+function bitAt(value, index) {
+	return (value >>> index & 1) !== 0;
+}
+function maskApplies(mask, x, y) {
+	switch (mask) {
+		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;
+		case 7: return ((x + y) % 2 + x * y % 3) % 2 === 0;
+	}
+}
+/** Mutable module grid used while one symbol is drawn. */
+var SymbolCanvas = class {
+	version;
+	size;
+	modules;
+	reserved;
+	constructor(version) {
+		this.version = version;
+		this.size = qrCodeSizeOf(version);
+		this.modules = Array.from({ length: this.size * this.size }).fill(false);
+		this.reserved = Array.from({ length: this.size * this.size }).fill(false);
+	}
+	get(x, y) {
+		return this.modules[y * this.size + x] === true;
+	}
+	setFunction(x, y, dark) {
+		this.modules[y * this.size + x] = dark;
+		this.reserved[y * this.size + x] = true;
+	}
+	drawFunctionPatterns() {
+		const { size } = this;
+		for (let index = 0; index < size; index++) {
+			this.setFunction(6, index, index % 2 === 0);
+			this.setFunction(index, 6, index % 2 === 0);
+		}
+		this.drawFinder(3, 3);
+		this.drawFinder(size - 4, 3);
+		this.drawFinder(3, size - 4);
+		const positions = alignmentPatternPositions(this.version);
+		const last = positions.length - 1;
+		positions.forEach((y, row) => {
+			positions.forEach((x, column) => {
+				if (!(row === 0 && column === 0 || row === 0 && column === last || row === last && column === 0)) this.drawAlignment(x, y);
+			});
+		});
+		this.drawFormat(formatInformationBits("M", 0));
+		this.drawVersion();
+	}
+	drawFinder(centerX, centerY) {
+		for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
+			const distance = Math.max(Math.abs(dx), Math.abs(dy));
+			const x = centerX + dx;
+			const y = centerY + dy;
+			if (x >= 0 && x < this.size && y >= 0 && y < this.size) this.setFunction(x, y, distance !== 2 && distance !== 4);
+		}
+	}
+	drawAlignment(centerX, centerY) {
+		for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) this.setFunction(centerX + dx, centerY + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+	}
+	drawFormat(bits) {
+		const { size } = this;
+		for (let index = 0; index <= 5; index++) this.setFunction(8, index, bitAt(bits, index));
+		this.setFunction(8, 7, bitAt(bits, 6));
+		this.setFunction(8, 8, bitAt(bits, 7));
+		this.setFunction(7, 8, bitAt(bits, 8));
+		for (let index = 9; index < 15; index++) this.setFunction(14 - index, 8, bitAt(bits, index));
+		for (let index = 0; index < 8; index++) this.setFunction(size - 1 - index, 8, bitAt(bits, index));
+		for (let index = 8; index < 15; index++) this.setFunction(8, size - 15 + index, bitAt(bits, index));
+		this.setFunction(8, size - 8, true);
+	}
+	drawVersion() {
+		if (this.version < 7) return;
+		const bits = versionInformationBits(this.version);
+		for (let index = 0; index < 18; index++) {
+			const dark = bitAt(bits, index);
+			const a = this.size - 11 + index % 3;
+			const b = Math.floor(index / 3);
+			this.setFunction(a, b, dark);
+			this.setFunction(b, a, dark);
+		}
+	}
+	drawCodewords(codewords) {
+		const { size } = this;
+		const totalBits = codewords.length * 8;
+		let bitIndex = 0;
+		for (let right = size - 1; right >= 1; right -= 2) {
+			if (right === 6) right = 5;
+			const upward = (right + 1 & 2) === 0;
+			for (let vertical = 0; vertical < size; vertical++) {
+				const y = upward ? size - 1 - vertical : vertical;
+				for (let offset = 0; offset < 2; offset++) {
+					const x = right - offset;
+					const index = y * size + x;
+					if (this.reserved[index] === true || bitIndex >= totalBits) continue;
+					this.modules[index] = bitAt(codewords[bitIndex >>> 3] ?? 0, 7 - (bitIndex & 7));
+					bitIndex++;
+				}
+			}
+		}
+	}
+	/** XOR a mask over data modules. Applying the same mask twice restores the grid. */
+	applyMask(mask) {
+		for (let y = 0; y < this.size; y++) for (let x = 0; x < this.size; x++) {
+			const index = y * this.size + x;
+			if (this.reserved[index] !== true && maskApplies(mask, x, y)) this.modules[index] = !this.modules[index];
+		}
+	}
+};
+/**
+* Standard mask penalty score (ISO/IEC 18004 §7.8.3): same-color runs, 2×2
+* blocks, finder-like patterns, and dark/light imbalance. Lower is better.
+*/
+function qrCodePenaltyScore(size, modules) {
+	const grid = new Uint8Array(size * size);
+	let darkCount = 0;
+	for (let index = 0; index < grid.length; index++) if (modules[index] === true) {
+		grid[index] = 1;
+		darkCount++;
+	}
+	const history = new Int32Array(7);
+	let result = 0;
+	for (let pass = 0; pass < 2; pass++) {
+		const horizontal = pass === 0;
+		for (let line = 0; line < size; line++) {
+			let runDark = 0;
+			let runLength = 0;
+			history.fill(0);
+			for (let cell = 0; cell < size; cell++) {
+				const dark = grid[horizontal ? line * size + cell : cell * size + line] ?? 0;
+				if (dark === runDark) {
+					runLength++;
+					if (runLength === 5) result += 3;
+					else if (runLength > 5) result++;
+				} else {
+					pushFinderRun(history, runLength, size);
+					if (runDark === 0) result += countFinderPatterns(history) * 40;
+					runDark = dark;
+					runLength = 1;
+				}
+			}
+			if (runDark === 1) {
+				pushFinderRun(history, runLength, size);
+				runLength = 0;
+			}
+			pushFinderRun(history, runLength + size, size);
+			result += countFinderPatterns(history) * 40;
+		}
+	}
+	for (let y = 0; y < size - 1; y++) {
+		const row = y * size;
+		for (let x = 0; x < size - 1; x++) {
+			const dark = grid[row + x];
+			if (dark === grid[row + x + 1] && dark === grid[row + size + x] && dark === grid[row + size + x + 1]) result += 3;
+		}
+	}
+	const total = size * size;
+	const k = Math.ceil(Math.abs(darkCount * 20 - total * 10) / total) - 1;
+	return result + k * 10;
+}
+/** Shift one run length into the 7-entry finder-pattern history (light border counts as `size`). */
+function pushFinderRun(history, runLength, size) {
+	const value = history[0] === 0 ? runLength + size : runLength;
+	history.copyWithin(1, 0, 6);
+	history[0] = value;
+}
+/** Count 1:1:3:1:1 finder-like patterns with a 4-module light margin on either side. */
+function countFinderPatterns(history) {
+	const n = history[1] ?? 0;
+	if (!(n > 0 && history[2] === n && history[3] === n * 3 && history[4] === n && history[5] === n)) return 0;
+	const before = history[0] ?? 0;
+	const after = history[6] ?? 0;
+	return (before >= n * 4 && after >= n ? 1 : 0) + (after >= n * 4 && before >= n ? 1 : 0);
+}
+function readVersionOption(name, value, fallback) {
+	if (value === void 0) return fallback;
+	if (!isVersion(value)) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", `${name} must be an integer in 1..40`);
+	return value;
+}
+/** ECI designator requested by `eci` / `utf8Eci`, or `null`. */
+function readEciOption(options) {
+	const explicit = options.eci;
+	if (options.utf8Eci === true) {
+		if (explicit !== void 0 && explicit !== UTF8_ECI) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", `utf8Eci conflicts with eci ${explicit}`);
+		return UTF8_ECI;
+	}
+	return explicit ?? null;
+}
+function isSegmentList(value) {
+	return Array.isArray(value);
+}
+function dataModeOf(segments) {
+	let mode = null;
+	for (const segment of segments) {
+		if (segment.mode === "eci") continue;
+		if (mode !== null && mode !== segment.mode) return "mixed";
+		mode = segment.mode;
+	}
+	return mode;
+}
+/**
+* Encode text, bytes, or explicit segments as an immutable QR Code symbol.
+*
+* Text is split into optimally mixed numeric, alphanumeric, byte (UTF-8), and
+* — with a `kanji` encoder — Kanji segments, re-optimized for each range of
+* character-count widths (versions 1–9, 10–26, 27–40). `segmentation:
+* "single"` or a forced `mode` keeps one segment. An `eci` / `utf8Eci` header
+* precedes the data when requested. The smallest fitting version is chosen
+* unless `version` fixes one, and the mask with the lowest penalty is applied
+* unless `mask` fixes one. Pure and deterministic, so it is safe during SSR.
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_DATA_TOO_LONG` when the value does
+* not fit the allowed versions, `VIZE_UI_QR_INVALID_MODE` when a forced mode
+* cannot represent it, or `VIZE_UI_QR_INVALID_OPTION` for out-of-range options.
+*/
+function encodeQrCode(value, options = {}) {
+	const requestedEcc = options.errorCorrection ?? "M";
+	if (!QR_CODE_ERROR_CORRECTION_LEVELS.includes(requestedEcc)) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "errorCorrection must be L, M, Q, or H");
+	const fixedVersion = options.version ?? "auto";
+	let minVersion;
+	let maxVersion;
+	if (fixedVersion === "auto") {
+		minVersion = readVersionOption("minVersion", options.minVersion, 1);
+		maxVersion = readVersionOption("maxVersion", options.maxVersion, 40);
+	} else {
+		minVersion = readVersionOption("version", fixedVersion, 1);
+		maxVersion = minVersion;
+	}
+	if (minVersion > maxVersion) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "minVersion must not exceed maxVersion");
+	const maskOption = options.mask ?? "auto";
+	if (maskOption !== "auto" && !isMask(maskOption)) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "mask must be an integer in 0..7");
+	const segmentation = options.segmentation ?? "optimal";
+	if (segmentation !== "optimal" && segmentation !== "single") throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "segmentation must be optimal or single");
+	const eci = readEciOption(options);
+	const header = eci === null ? [] : [createQrCodeEciSegment(eci)];
+	const segmentsFor = (candidate) => {
+		if (isSegmentList(value)) return [...header, ...value];
+		const data = createQrCodeSegments(value, {
+			kanji: options.kanji,
+			mode: options.mode ?? "auto",
+			segmentation,
+			version: candidate
+		});
+		return [...header, ...data];
+	};
+	const rangeStarts = new Set([
+		minVersion,
+		10,
+		27
+	]);
+	let segments = [];
+	let version = null;
+	let usedBits = 0;
+	for (let candidate = minVersion; candidate <= maxVersion; candidate++) {
+		if (!isVersion(candidate)) break;
+		if (rangeStarts.has(candidate)) segments = segmentsFor(candidate);
+		const bits = qrCodeSegmentBitLength(segments, candidate);
+		if (bits <= dataCodewordCount(candidate, requestedEcc) * 8) {
+			version = candidate;
+			usedBits = bits;
+			break;
+		}
+	}
+	if (version === null) throw new QrCodeEncodeError("VIZE_UI_QR_DATA_TOO_LONG", `value does not fit version ${maxVersion} at error correction ${requestedEcc}`);
+	let ecc = requestedEcc;
+	if (options.boostErrorCorrection === true) {
+		for (const level of QR_CODE_ERROR_CORRECTION_LEVELS) if (usedBits <= dataCodewordCount(version, level) * 8) ecc = level;
+	}
+	const codewords = addErrorCorrectionAndInterleave(createDataCodewords(segments, version, ecc), version, ecc);
+	const canvas = new SymbolCanvas(version);
+	canvas.drawFunctionPatterns();
+	canvas.drawCodewords(codewords);
+	let mask;
+	if (maskOption === "auto") {
+		mask = 0;
+		let lowest = Number.POSITIVE_INFINITY;
+		for (const candidate of MASKS) {
+			canvas.applyMask(candidate);
+			canvas.drawFormat(formatInformationBits(ecc, candidate));
+			const penalty = qrCodePenaltyScore(canvas.size, canvas.modules);
+			if (penalty < lowest) {
+				mask = candidate;
+				lowest = penalty;
+			}
+			canvas.applyMask(candidate);
+		}
+	} else mask = maskOption;
+	canvas.applyMask(mask);
+	canvas.drawFormat(formatInformationBits(ecc, mask));
+	return Object.freeze({
+		version,
+		size: canvas.size,
+		errorCorrection: ecc,
+		mask,
+		mode: dataModeOf(segments),
+		segments: Object.freeze(segments.map((segment) => Object.freeze({
+			mode: segment.mode,
+			count: segment.mode === "eci" ? eciDesignatorOf(segment) : segment.count
+		}))),
+		eci,
+		modules: Object.freeze([...canvas.modules])
+	});
+}
+/** Decode the designator from an ECI segment's 8/16/24 payload bits. */
+function eciDesignatorOf(segment) {
+	const prefix = segment.bits[0] === 0 ? 1 : segment.bits[1] === 0 ? 2 : 3;
+	let value = 0;
+	for (const bit of segment.bits.slice(prefix)) value = value * 2 + bit;
+	return value;
+}
+/** Whether the module at `(x, y)` is dark. Coordinates outside the symbol are light. */
+function isQrCodeModuleDark(matrix, x, y) {
+	if (x < 0 || y < 0 || x >= matrix.size || y >= matrix.size) return false;
+	return matrix.modules[y * matrix.size + x] === true;
+}
+/**
+* Maximum characters a mode holds at a version and level. Useful for input
+* limits and for choosing a stronger level when a logo covers the symbol.
+*/
+function qrCodeCapacity(version, errorCorrection, mode) {
+	const available = dataCodewordCount(version, errorCorrection) * 8 - 4 - characterCountBits(mode, version);
+	const maxCount = 2 ** characterCountBits(mode, version) - 1;
+	let count;
+	switch (mode) {
+		case "numeric": {
+			const groups = Math.floor(available / 10);
+			const rest = available - groups * 10;
+			count = groups * 3 + (rest >= 7 ? 2 : rest >= 4 ? 1 : 0);
+			break;
+		}
+		case "alphanumeric": {
+			const pairs = Math.floor(available / 11);
+			count = pairs * 2 + (available - pairs * 11 >= 6 ? 1 : 0);
+			break;
+		}
+		case "byte":
+			count = Math.floor(available / 8);
+			break;
+		case "kanji":
+			count = Math.floor(available / 13);
+			break;
+	}
+	return Math.min(count, maxCount);
+}
+//#endregion
+//#region src/families/media/qr-code/qr-code-svg.ts
+/**
+* Validate a quiet zone width. The standard requires 4 modules; smaller
+* values are allowed for layouts that supply their own light margin.
+*
+* @throws {QrCodeEncodeError} `VIZE_UI_QR_INVALID_OPTION` for negative or
+* non-integer widths.
+*/
+function normalizeQrCodeQuietZone(quietZone) {
+	if (!Number.isInteger(quietZone) || quietZone < 0 || quietZone > 64) throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "quietZone must be an integer in 0..64");
+	return quietZone;
+}
+/**
+* Build one deterministic SVG path `d` string covering every dark module.
+*
+* Horizontal runs of dark modules are merged into a single rectangle each
+* (`M x y h n v1 h -n z`), so the output stays compact and renders without
+* hairline seams under `shape-rendering="crispEdges"`. Coordinates are in
+* module units, offset by the quiet zone, matching a
+* `viewBox="0 0 size+2q size+2q"`.
+*/
+function qrCodeToSvgPath(matrix, options = {}) {
+	const offset = normalizeQrCodeQuietZone(options.quietZone ?? 0);
+	const { size, modules } = matrix;
+	const commands = [];
+	for (let y = 0; y < size; y++) {
+		let x = 0;
+		while (x < size) {
+			if (modules[y * size + x] !== true) {
+				x++;
+				continue;
+			}
+			const start = x;
+			while (x < size && modules[y * size + x] === true) x++;
+			const length = x - start;
+			commands.push(`M${start + offset} ${y + offset}h${length}v1h-${length}z`);
+		}
+	}
+	return commands.join("");
+}
+//#endregion
+//#region src/families/media/qr-code/qr-code.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"viewBox",
+	"role",
+	"aria-label",
+	"aria-hidden",
+	"data-version",
+	"data-error-correction",
+	"data-mask",
+	"data-mode",
+	"data-size"
+];
+const _hoisted_2 = { key: 0 };
+const _hoisted_3 = [
+	"width",
+	"height",
+	"fill"
+];
+const _hoisted_4 = ["d", "fill"];
+const _hoisted_5 = ["data-error"];
+//#endregion
+//#region src/families/media/qr-code/qr-code.vue
+var qr_code_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "qr-code",
+	props: {
+		value: {
+			type: null,
+			required: true
+		},
+		errorCorrection: {
+			type: String,
+			required: false,
+			default: "M"
+		},
+		boostErrorCorrection: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		version: {
+			type: [Number, String],
+			required: false,
+			default: "auto"
+		},
+		mask: {
+			type: [Number, String],
+			required: false,
+			default: "auto"
+		},
+		mode: {
+			type: String,
+			required: false,
+			default: "auto"
+		},
+		segmentation: {
+			type: String,
+			required: false,
+			default: "optimal"
+		},
+		kanji: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		},
+		eci: {
+			type: Number,
+			required: false,
+			default: () => void 0
+		},
+		utf8Eci: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		quietZone: {
+			type: Number,
+			required: false,
+			default: 4
+		},
+		label: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		decorative: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		foreground: {
+			type: String,
+			required: false,
+			default: "currentColor"
+		},
+		background: {
+			type: String,
+			required: false,
+			default: "none"
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const encoding = computed(() => {
+			try {
+				const zone = normalizeQrCodeQuietZone(__props.quietZone);
+				return {
+					matrix: encodeQrCode(__props.value, {
+						boostErrorCorrection: __props.boostErrorCorrection,
+						eci: __props.eci,
+						errorCorrection: __props.errorCorrection,
+						kanji: __props.kanji,
+						mask: __props.mask,
+						mode: __props.mode,
+						segmentation: __props.segmentation,
+						utf8Eci: __props.utf8Eci,
+						version: __props.version
+					}),
+					error: null,
+					quietZone: zone
+				};
+			} catch (error) {
+				if (error instanceof QrCodeEncodeError) return {
+					matrix: null,
+					error,
+					quietZone: 0
+				};
+				throw error;
+			}
+		});
+		const matrix = computed(() => encoding.value.matrix);
+		const error = computed(() => encoding.value.error);
+		const zone = computed(() => encoding.value.quietZone);
+		const state = computed(() => matrix.value === null ? "error" : "ready");
+		const dimension = computed(() => matrix.value === null ? 0 : matrix.value.size + zone.value * 2);
+		const path = computed(() => matrix.value === null ? "" : qrCodeToSvgPath(matrix.value, { quietZone: zone.value }));
+		const versionAttribute = computed(() => matrix.value?.version);
+		const errorCorrectionAttribute = computed(() => matrix.value?.errorCorrection);
+		const maskAttribute = computed(() => matrix.value?.mask);
+		const modeAttribute = computed(() => matrix.value?.mode ?? void 0);
+		const sizeAttribute = computed(() => matrix.value?.size);
+		const errorCode = computed(() => error.value?.code);
+		const accessibleName = computed(() => {
+			if (__props.decorative) return void 0;
+			if (__props.label !== void 0) return __props.label;
+			return typeof __props.value === "string" ? __props.value : void 0;
+		});
+		const slotState = computed(() => ({
+			dimension: dimension.value,
+			error: error.value,
+			matrix: matrix.value,
+			quietZone: zone.value,
+			state: state.value
+		}));
+		__expose({
+			dimension,
+			element,
+			error,
+			matrix,
+			quietZone: zone,
+			state
+		});
+		return (_ctx, _cache) => {
+			return matrix.value !== null ? (openBlock(), createElementBlock("svg", {
+				key: 0,
+				ref_key: "element",
+				ref: element,
+				xmlns: "http://www.w3.org/2000/svg",
+				viewBox: `0 0 ${dimension.value} ${dimension.value}`,
+				"shape-rendering": "crispEdges",
+				role: __props.decorative ? void 0 : "img",
+				"aria-label": accessibleName.value,
+				"aria-hidden": __props.decorative ? "true" : void 0,
+				"data-vize-ui": "qr-code",
+				part: "root",
+				"data-state": "ready",
+				"data-version": versionAttribute.value,
+				"data-error-correction": errorCorrectionAttribute.value,
+				"data-mask": maskAttribute.value,
+				"data-mode": modeAttribute.value,
+				"data-size": sizeAttribute.value
+			}, [
+				accessibleName.value !== void 0 ? (openBlock(), createElementBlock("title", _hoisted_2, toDisplayString(accessibleName.value), 1)) : createCommentVNode("v-if", true),
+				createElementVNode("rect", {
+					part: "background",
+					"data-vize-ui": "qr-code-background",
+					width: dimension.value,
+					height: dimension.value,
+					fill: __props.background
+				}, null, 8, _hoisted_3),
+				createElementVNode("path", {
+					part: "modules",
+					"data-vize-ui": "qr-code-modules",
+					d: path.value,
+					fill: __props.foreground
+				}, null, 8, _hoisted_4),
+				renderSlot(_ctx.$slots, "overlay", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)
+			], 8, _hoisted_1)) : (openBlock(), createElementBlock("span", {
+				key: 1,
+				"data-vize-ui": "qr-code",
+				part: "root",
+				"data-state": "error",
+				"data-error": errorCode.value
+			}, [renderSlot(_ctx.$slots, "fallback", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)], 8, _hoisted_5));
+		};
+	}
+}), [["__scopeId", "data-v-736c5954"]]);
+//#endregion
+export { qrCodeCapacity as a, createQrCodeEciSegment as c, createQrCodeSegments as d, qrCodeSegmentBitLength as f, isQrCodeModuleDark as i, createQrCodeKanjiSegment as l, qrCodeToSvgPath as n, createQrCodeAlphanumericSegment as o, QrCodeEncodeError as p, encodeQrCode as r, createQrCodeByteSegment as s, qr_code_default as t, createQrCodeNumericSegment as u };