@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/qrcode/encoder.js

@@ -0,0 +1,786 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/defineProperty.js";
+// src/qrcode/encoder.ts
+var MIN_VERSION = 1;
+var MAX_VERSION = 40;
+var LEVELS = [
+	"L",
+	"M",
+	"Q",
+	"H"
+];
+/** The two format bits of every level */
+var LEVEL_FORMAT_BITS = {
+	L: 1,
+	M: 0,
+	Q: 3,
+	H: 2
+};
+var MODE_BITS = {
+	numeric: 1,
+	alphanumeric: 2,
+	byte: 4
+};
+/** Width of the character count field for versions 1-9, 10-26, 27-40 */
+var CHAR_COUNT_BITS = {
+	numeric: [
+		10,
+		12,
+		14
+	],
+	alphanumeric: [
+		9,
+		11,
+		13
+	],
+	byte: [
+		8,
+		16,
+		16
+	]
+};
+var NUMERIC_REGEX = /^\d*$/;
+var ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
+var ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+/** Error correction codewords per block, indexed by level then version - 1 */
+var ECC_CODEWORDS_PER_BLOCK = {
+	L: [
+		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: [
+		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: [
+		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: [
+		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
+	]
+};
+/** Number of error correction blocks, indexed by level then version - 1 */
+var NUM_ERROR_CORRECTION_BLOCKS = {
+	L: [
+		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,
+		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,
+		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,
+		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
+	]
+};
+var PENALTY_N1 = 3;
+var PENALTY_N2 = 3;
+var PENALTY_N3 = 40;
+var PENALTY_N4 = 10;
+function appendBits(value, length, bits) {
+	for (let i = length - 1; i >= 0; i--) bits.push(value >>> i & 1);
+}
+/** UTF-8 bytes of a string (lone surrogates become U+FFFD) */
+function toUtf8Bytes(text) {
+	const bytes = [];
+	for (let i = 0; i < text.length; i++) {
+		let code = text.codePointAt(i);
+		if (code > 65535) i++;
+		else if (code >= 55296 && code <= 57343) code = 65533;
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >>> 6, 128 | code & 63);
+		else if (code < 65536) bytes.push(224 | code >>> 12, 128 | code >>> 6 & 63, 128 | code & 63);
+		else bytes.push(240 | code >>> 18, 128 | code >>> 12 & 63, 128 | code >>> 6 & 63, 128 | code & 63);
+	}
+	return bytes;
+}
+function makeSegment(text) {
+	if (text === "") return void 0;
+	const bits = [];
+	if (NUMERIC_REGEX.test(text)) {
+		for (let i = 0; i < text.length; i += 3) {
+			const chunk = text.slice(i, i + 3);
+			appendBits(Number.parseInt(chunk, 10), chunk.length * 3 + 1, bits);
+		}
+		return {
+			mode: "numeric",
+			numChars: text.length,
+			bits
+		};
+	}
+	if (ALPHANUMERIC_REGEX.test(text)) {
+		let i = 0;
+		for (; i + 2 <= text.length; i += 2) appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45 + ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1)), 11, bits);
+		if (i < text.length) appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bits);
+		return {
+			mode: "alphanumeric",
+			numChars: text.length,
+			bits
+		};
+	}
+	const bytes = toUtf8Bytes(text);
+	bytes.forEach((byte) => appendBits(byte, 8, bits));
+	return {
+		mode: "byte",
+		numChars: bytes.length,
+		bits
+	};
+}
+function charCountBits(mode, version) {
+	return CHAR_COUNT_BITS[mode][Math.floor((version + 7) / 17)];
+}
+/** Bits needed by the segments at `version`, `Infinity` when a segment is too long for its count field */
+function getTotalBits(segments, version) {
+	let result = 0;
+	for (const segment of segments) {
+		const countBits = charCountBits(segment.mode, version);
+		if (segment.numChars >= 1 << countBits) return Infinity;
+		result += 4 + countBits + segment.bits.length;
+	}
+	return result;
+}
+/** Number of data + error correction bits of a version (function patterns excluded) */
+function getNumRawDataModules(version) {
+	let result = (16 * version + 128) * version + 64;
+	if (version >= 2) {
+		const numAlign = Math.floor(version / 7) + 2;
+		result -= (25 * numAlign - 10) * numAlign - 55;
+		if (version >= 7) result -= 36;
+	}
+	return result;
+}
+function getNumDataCodewords(version, level) {
+	return Math.floor(getNumRawDataModules(version) / 8) - ECC_CODEWORDS_PER_BLOCK[level][version - 1] * NUM_ERROR_CORRECTION_BLOCKS[level][version - 1];
+}
+/** Product of two field elements in GF(2^8 / 0x11D) */
+function gfMultiply(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;
+}
+/** Coefficients of the generator polynomial of the given degree (highest power dropped) */
+function reedSolomonDivisor(degree) {
+	const result = Array.from({ length: degree }).fill(0);
+	result[degree - 1] = 1;
+	let root = 1;
+	for (let i = 0; i < degree; i++) {
+		for (let j = 0; j < degree; j++) {
+			result[j] = gfMultiply(result[j], root);
+			if (j + 1 < degree) result[j] ^= result[j + 1];
+		}
+		root = gfMultiply(root, 2);
+	}
+	return result;
+}
+function reedSolomonRemainder(data, divisor) {
+	const result = divisor.map(() => 0);
+	for (const byte of data) {
+		const factor = byte ^ result.shift();
+		result.push(0);
+		for (let i = 0; i < divisor.length; i++) result[i] ^= gfMultiply(divisor[i], factor);
+	}
+	return result;
+}
+/** Splits the data codewords into blocks, appends the error correction and interleaves everything */
+function addEccAndInterleave(data, version, level) {
+	const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[level][version - 1];
+	const blockEccLen = ECC_CODEWORDS_PER_BLOCK[level][version - 1];
+	const rawCodewords = Math.floor(getNumRawDataModules(version) / 8);
+	const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+	const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+	const blocks = [];
+	const divisor = reedSolomonDivisor(blockEccLen);
+	for (let i = 0, k = 0; i < numBlocks; i++) {
+		const dataLen = shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1);
+		const block = data.slice(k, k + dataLen);
+		k += dataLen;
+		const ecc = reedSolomonRemainder(block, divisor);
+		if (i < numShortBlocks) block.push(0);
+		blocks.push(block.concat(ecc));
+	}
+	const result = [];
+	for (let i = 0; i < blocks[0].length; i++) for (let j = 0; j < blocks.length; j++) if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(blocks[j][i]);
+	return result;
+}
+function getAlignmentPatternPositions(version) {
+	if (version === 1) return [];
+	const size = version * 4 + 17;
+	const numAlign = Math.floor(version / 7) + 2;
+	const step = version === 32 ? 26 : Math.ceil((version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+	const result = [6];
+	for (let pos = size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
+	return result;
+}
+function getMaskBit(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;
+		default: return ((x + y) % 2 + x * y % 3) % 2 === 0;
+	}
+}
+var Matrix = class {
+	constructor(version, level) {
+		_defineProperty(this, "version", void 0);
+		_defineProperty(this, "level", void 0);
+		_defineProperty(this, "size", void 0);
+		_defineProperty(this, "modules", void 0);
+		_defineProperty(this, "isFunction", void 0);
+		this.version = version;
+		this.level = level;
+		const size = this.size = version * 4 + 17;
+		this.modules = Array.from({ length: size }, () => Array.from({ length: size }).fill(false));
+		this.isFunction = Array.from({ length: size }, () => Array.from({ length: size }).fill(false));
+	}
+	setFunction(x, y, dark) {
+		this.modules[y][x] = dark;
+		this.isFunction[y][x] = true;
+	}
+	drawFunctionPatterns() {
+		const { size } = this;
+		for (let i = 0; i < size; i++) {
+			this.setFunction(6, i, i % 2 === 0);
+			this.setFunction(i, 6, i % 2 === 0);
+		}
+		this.drawFinder(3, 3);
+		this.drawFinder(size - 4, 3);
+		this.drawFinder(3, size - 4);
+		const positions = getAlignmentPatternPositions(this.version);
+		const last = positions.length - 1;
+		for (let i = 0; i <= last; i++) for (let j = 0; j <= last; j++) if (!(i === 0 && j === 0 || i === 0 && j === last || i === last && j === 0)) this.drawAlignment(positions[i], positions[j]);
+		this.drawFormatBits(0);
+		this.drawVersion();
+	}
+	drawFinder(cx, cy) {
+		for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
+			const dist = Math.max(Math.abs(dx), Math.abs(dy));
+			const x = cx + dx;
+			const y = cy + dy;
+			if (x >= 0 && x < this.size && y >= 0 && y < this.size) this.setFunction(x, y, dist !== 2 && dist !== 4);
+		}
+	}
+	drawAlignment(cx, cy) {
+		for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) this.setFunction(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+	}
+	drawFormatBits(mask) {
+		const { size } = this;
+		const data = LEVEL_FORMAT_BITS[this.level] << 3 | mask;
+		let rem = data;
+		for (let i = 0; i < 10; i++) rem = rem << 1 ^ (rem >>> 9) * 1335;
+		const bits = (data << 10 | rem) ^ 21522;
+		const bit = (i) => (bits >>> i & 1) !== 0;
+		for (let i = 0; i <= 5; i++) this.setFunction(8, i, bit(i));
+		this.setFunction(8, 7, bit(6));
+		this.setFunction(8, 8, bit(7));
+		this.setFunction(7, 8, bit(8));
+		for (let i = 9; i < 15; i++) this.setFunction(14 - i, 8, bit(i));
+		for (let i = 0; i < 8; i++) this.setFunction(size - 1 - i, 8, bit(i));
+		for (let i = 8; i < 15; i++) this.setFunction(8, size - 15 + i, bit(i));
+		this.setFunction(8, size - 8, true);
+	}
+	drawVersion() {
+		if (this.version < 7) return;
+		let rem = this.version;
+		for (let i = 0; i < 12; i++) rem = rem << 1 ^ (rem >>> 11) * 7973;
+		const bits = this.version << 12 | rem;
+		for (let i = 0; i < 18; i++) {
+			const dark = (bits >>> i & 1) !== 0;
+			const a = this.size - 11 + i % 3;
+			const b = Math.floor(i / 3);
+			this.setFunction(a, b, dark);
+			this.setFunction(b, a, dark);
+		}
+	}
+	/** Places the codewords in the zigzag order, skipping function modules */
+	drawCodewords(data) {
+		const { size } = this;
+		const total = data.length * 8;
+		let i = 0;
+		for (let right = size - 1; right >= 1; right -= 2) {
+			if (right === 6) right = 5;
+			for (let vert = 0; vert < size; vert++) for (let j = 0; j < 2; j++) {
+				const x = right - j;
+				const y = (right + 1 & 2) === 0 ? size - 1 - vert : vert;
+				if (!this.isFunction[y][x] && i < total) {
+					this.modules[y][x] = (data[i >>> 3] >>> 7 - (i & 7) & 1) !== 0;
+					i++;
+				}
+			}
+		}
+	}
+	/** XOR the data modules with a mask pattern (calling it twice undoes it) */
+	applyMask(mask) {
+		for (let y = 0; y < this.size; y++) for (let x = 0; x < this.size; x++) if (!this.isFunction[y][x] && getMaskBit(mask, x, y)) this.modules[y][x] = !this.modules[y][x];
+	}
+	getPenaltyScore() {
+		const { size, modules } = this;
+		let result = 0;
+		const addHistory = (runLength, history) => {
+			if (history[0] === 0) runLength += size;
+			history.pop();
+			history.unshift(runLength);
+		};
+		const countPatterns = (history) => {
+			const n = history[1];
+			const core = n > 0 && history[2] === n && history[3] === n * 3 && history[4] === n && history[5] === n;
+			return (core && history[0] >= n * 4 && history[6] >= n ? 1 : 0) + (core && history[6] >= n * 4 && history[0] >= n ? 1 : 0);
+		};
+		const terminateAndCount = (runColor, runLength, history) => {
+			if (runColor) {
+				addHistory(runLength, history);
+				runLength = 0;
+			}
+			runLength += size;
+			addHistory(runLength, history);
+			return countPatterns(history);
+		};
+		for (let pass = 0; pass < 2; pass++) for (let a = 0; a < size; a++) {
+			let runColor = false;
+			let runLength = 0;
+			const history = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let b = 0; b < size; b++) {
+				const dark = pass === 0 ? modules[a][b] : modules[b][a];
+				if (dark === runColor) {
+					runLength++;
+					if (runLength === 5) result += PENALTY_N1;
+					else if (runLength > 5) result++;
+				} else {
+					addHistory(runLength, history);
+					if (!runColor) result += countPatterns(history) * PENALTY_N3;
+					runColor = dark;
+					runLength = 1;
+				}
+			}
+			result += terminateAndCount(runColor, runLength, history) * PENALTY_N3;
+		}
+		for (let y = 0; y < size - 1; y++) for (let x = 0; x < size - 1; x++) {
+			const color = modules[y][x];
+			if (color === modules[y][x + 1] && color === modules[y + 1][x] && color === modules[y + 1][x + 1]) result += PENALTY_N2;
+		}
+		let dark = 0;
+		for (const row of modules) for (const cell of row) if (cell) dark++;
+		const total = size * size;
+		const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+		result += k * PENALTY_N4;
+		return result;
+	}
+};
+function clampVersion(value, fallback) {
+	const version = Math.floor(Number(value));
+	return version >= MIN_VERSION && version <= MAX_VERSION ? version : fallback;
+}
+/**
+* Encodes a text (or several texts, each one as its own optimally typed segment) into a QR Code matrix.
+* Throws a `RangeError` when the data does not fit in version 40 (or `maxVersion`) at the requested level.
+*/
+function encodeQRCode(value, options = {}) {
+	const { boostLevel = true } = options;
+	let level = LEVELS.includes(options.errorLevel) ? options.errorLevel : "M";
+	const minVersion = clampVersion(options.minVersion, MIN_VERSION);
+	const maxVersion = Math.max(clampVersion(options.maxVersion, MAX_VERSION), minVersion);
+	const segments = [];
+	for (const text of Array.isArray(value) ? value : [value]) {
+		const segment = makeSegment(String(text ?? ""));
+		if (segment) segments.push(segment);
+	}
+	let version = minVersion;
+	let usedBits = 0;
+	for (;; version++) {
+		usedBits = getTotalBits(segments, version);
+		if (usedBits <= getNumDataCodewords(version, level) * 8) break;
+		if (version >= maxVersion) throw new RangeError("[@antdv-next/mobile: QRCode] Data too long");
+	}
+	if (boostLevel) {
+		for (const next of LEVELS.slice(LEVELS.indexOf(level) + 1)) if (usedBits <= getNumDataCodewords(version, next) * 8) level = next;
+	}
+	const capacityBits = getNumDataCodewords(version, level) * 8;
+	const bits = [];
+	for (const segment of segments) {
+		appendBits(MODE_BITS[segment.mode], 4, bits);
+		appendBits(segment.numChars, charCountBits(segment.mode, version), bits);
+		for (const bit of segment.bits) bits.push(bit);
+	}
+	appendBits(0, Math.min(4, capacityBits - bits.length), bits);
+	appendBits(0, (8 - bits.length % 8) % 8, bits);
+	for (let pad = 236; bits.length < capacityBits; pad ^= 253) appendBits(pad, 8, bits);
+	const dataCodewords = Array.from({ length: bits.length >>> 3 }).fill(0);
+	bits.forEach((bit, i) => {
+		dataCodewords[i >>> 3] |= bit << 7 - (i & 7);
+	});
+	const matrix = new Matrix(version, level);
+	matrix.drawFunctionPatterns();
+	matrix.drawCodewords(addEccAndInterleave(dataCodewords, version, level));
+	let mask = Math.floor(Number(options.mask));
+	if (!(mask >= 0 && mask <= 7)) {
+		mask = 0;
+		let minPenalty = Infinity;
+		for (let i = 0; i < 8; i++) {
+			matrix.applyMask(i);
+			matrix.drawFormatBits(i);
+			const penalty = matrix.getPenaltyScore();
+			if (penalty < minPenalty) {
+				mask = i;
+				minPenalty = penalty;
+			}
+			matrix.applyMask(i);
+		}
+	}
+	matrix.applyMask(mask);
+	matrix.drawFormatBits(mask);
+	return {
+		version,
+		size: matrix.size,
+		errorLevel: level,
+		mask,
+		modules: matrix.modules
+	};
+}
+/** Clears the modules covered by the icon */
+function excavateModules(modules, excavation) {
+	return modules.map((row, y) => {
+		if (y < excavation.y || y >= excavation.y + excavation.h) return row;
+		return row.map((cell, x) => x < excavation.x || x >= excavation.x + excavation.w ? cell : false);
+	});
+}
+/** One SVG path (horizontal runs merged) for all dark modules, in module units */
+function generatePath(modules, margin = 0) {
+	const ops = [];
+	modules.forEach((row, y) => {
+		let start = -1;
+		for (let x = 0; x <= row.length; x++) {
+			const dark = x < row.length && row[x];
+			if (dark && start < 0) start = x;
+			else if (!dark && start >= 0) {
+				ops.push(`M${start + margin} ${y + margin}h${x - start}v1H${start + margin}z`);
+				start = -1;
+			}
+		}
+	});
+	return ops.join("");
+}
+export { encodeQRCode, excavateModules, generatePath, toUtf8Bytes };