sard 1.0.0 → 1.0.2

package/utils/qrcode.js

@@ -0,0 +1,768 @@
+//#region packages/sard/utils/qrcode.ts
+const LOG = /* @__PURE__ */ new Uint8Array(256);
+const EXP = /* @__PURE__ */ new Uint8Array(256);
+(() => {
+	for (let exponent = 1, value = 1; exponent < 256; exponent++) {
+		value = value > 127 ? value << 1 ^ 285 : value << 1;
+		LOG[value] = exponent % 255;
+		EXP[exponent % 255] = value;
+	}
+})();
+function mul(a, b) {
+	return a && b ? EXP[(LOG[a] + LOG[b]) % 255] : 0;
+}
+function div(a, b) {
+	return EXP[(LOG[a] + LOG[b] * 254) % 255];
+}
+function polyMul(poly1, poly2) {
+	const coeffs = new Uint8Array(poly1.length + poly2.length - 1);
+	for (let index = 0; index < coeffs.length; index++) {
+		let coeff = 0;
+		for (let p1index = 0; p1index <= index; p1index++) {
+			const p2index = index - p1index;
+			coeff ^= mul(poly1[p1index], poly2[p2index]);
+		}
+		coeffs[index] = coeff;
+	}
+	return coeffs;
+}
+function polyRest(dividend, divisor) {
+	const quotientLength = dividend.length - divisor.length + 1;
+	let rest = new Uint8Array(dividend);
+	for (let count = 0; count < quotientLength; count++) if (rest[0]) {
+		const factor = div(rest[0], divisor[0]);
+		const subtr = new Uint8Array(rest.length);
+		subtr.set(polyMul(divisor, new Uint8Array([factor])), 0);
+		rest = rest.map((value, index) => value ^ subtr[index]).slice(1);
+	} else rest = rest.slice(1);
+	return rest;
+}
+const cacheGeneratorPoly = {};
+function getGeneratorPoly(degree) {
+	if (cacheGeneratorPoly[degree]) return cacheGeneratorPoly[degree];
+	let lastPoly = new Uint8Array([1]);
+	for (let index = 0; index < degree; index++) lastPoly = polyMul(lastPoly, new Uint8Array([1, EXP[index]]));
+	return cacheGeneratorPoly[degree] = lastPoly;
+}
+function getECC(data, degree) {
+	const messagePoly = new Uint8Array(data.length + degree);
+	messagePoly.set(data, 0);
+	return polyRest(messagePoly, getGeneratorPoly(degree));
+}
+const ECCodewordsPerBlock = [
+	[
+		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
+	],
+	[
+		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
+	],
+	[
+		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
+	],
+	[
+		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 ECBlocks = [
+	[
+		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,
+		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,
+		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,
+		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 appendBits(num, length, bits) {
+	for (let i = length - 1; i >= 0; i--) bits.push(num >>> i & 1);
+	return bits;
+}
+var Mode = /* @__PURE__ */ function(Mode) {
+	Mode[Mode["Numeric"] = 0] = "Numeric";
+	Mode[Mode["Alphanumeric"] = 1] = "Alphanumeric";
+	Mode[Mode["Byte"] = 2] = "Byte";
+	return Mode;
+}(Mode || {});
+function getMode(text) {
+	if (/^[0-9]*$/.test(text)) return Mode.Numeric;
+	if (/^[0-9A-Z $%*+-./:]*$/.test(text)) return Mode.Alphanumeric;
+	return Mode.Byte;
+}
+function getModeIndicator(mode) {
+	switch (mode) {
+		case Mode.Numeric: return 1;
+		case Mode.Alphanumeric: return 2;
+		default: return 4;
+	}
+}
+function encodeNumeric(text) {
+	const bits = [];
+	(text.match(/.{1,3}/g) || []).forEach((item) => {
+		appendBits(+item, (item.length - 1) * 3 + 4, bits);
+	});
+	return bits;
+}
+const ALPHANUMERIC_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+function encodeAlphaNumeric(text) {
+	const bits = [];
+	(text.match(/.{1,2}/g) || []).forEach((item) => {
+		const i1 = ALPHANUMERIC_CHARS.indexOf(item[0]);
+		const i2 = ALPHANUMERIC_CHARS.indexOf(item[1]);
+		if (i2 === -1) appendBits(i1, 6, bits);
+		else appendBits(i1 * 45 + i2, 11, bits);
+	});
+	return bits;
+}
+function toUtf8ByteArray(text) {
+	text = encodeURI(text);
+	const bytes = [];
+	for (let i = 0; i < text.length; i++) if (text.charAt(i) !== "%") bytes.push(text.charCodeAt(i));
+	else {
+		bytes.push(parseInt(text.slice(i + 1, i + 3), 16));
+		i += 2;
+	}
+	return bytes;
+}
+function encodeByte(text) {
+	const bits = [];
+	toUtf8ByteArray(text).forEach((item) => {
+		appendBits(item, 8, bits);
+	});
+	return bits;
+}
+function encodeData(mode, text) {
+	switch (mode) {
+		case Mode.Numeric: return encodeNumeric(text);
+		case Mode.Alphanumeric: return encodeAlphaNumeric(text);
+		default: return encodeByte(text);
+	}
+}
+function getFunctionModules(version) {
+	let count = 225 + 8 * version;
+	if (version > 6) count += 36;
+	if (version > 1) {
+		const alignCount = ~~(version / 7) + 2;
+		count += (25 * alignCount - 10) * alignCount - 55;
+	}
+	return count;
+}
+function getSize(version) {
+	return version * 4 + 17;
+}
+function getTotalDataModules(version) {
+	return Math.pow(getSize(version), 2) - getFunctionModules(version);
+}
+function getECCodewords(eclIndex, version) {
+	return ECCodewordsPerBlock[eclIndex][version - 1] * ECBlocks[eclIndex][version - 1];
+}
+function getRawDataCodewords(eclIndex, version) {
+	return getTotalDataModules(version) / 8 - getECCodewords(eclIndex, version);
+}
+const charCountIndicatorTable = {
+	[Mode.Numeric]: [
+		10,
+		12,
+		14
+	],
+	[Mode.Alphanumeric]: [
+		9,
+		11,
+		13
+	],
+	[Mode.Byte]: [
+		8,
+		16,
+		16
+	]
+};
+function getCharCountIndicator(mode, version) {
+	return charCountIndicatorTable[mode][~~((version + 7) / 17)];
+}
+function getVersion(mode, eclIndex, codewords) {
+	for (let version = 1; version <= 40; version++) if (getRawDataCodewords(eclIndex, version) >= codewords + (4 + getCharCountIndicator(mode, version)) / 8) return version;
+	return 40;
+}
+function addFinderPatterns(map, size) {
+	for (let i = 0; i < 3; i++) {
+		const originX = i === 1 ? size - 7 : 0;
+		const originY = i === 2 ? size - 7 : 0;
+		for (let y = 0; y < 7; y++) for (let x = 0; x < 7; x++) {
+			const bit = x === 0 || x === 6 || y === 0 || y === 6 || x > 1 && x < 5 && y > 1 && y < 5 ? 1 : 0;
+			map[originY + y][originX + x] = bit;
+		}
+	}
+}
+function addSeparatorPatterns(map, size) {
+	for (let i = 0; i < 8; i++) {
+		map[i][7] = 0;
+		map[i][size - 8] = 0;
+		map[size - 8 + i][7] = 0;
+		map[7][i] = 0;
+		map[7][size - 8 + i] = 0;
+		map[size - 8][i] = 0;
+	}
+}
+function getAlignmentPatternLocations(version) {
+	if (version == 1) return [];
+	const alignCount = ~~(version / 7) + 2;
+	const step = version === 32 ? 26 : Math.ceil((version * 4 + 4) / (alignCount * 2 - 2)) * 2;
+	const locations = [6];
+	for (let location = getSize(version) - 7; locations.length < alignCount; location -= step) locations.splice(1, 0, location);
+	return locations;
+}
+function addAlignmentPatterns(map, version) {
+	const locations = getAlignmentPatternLocations(version);
+	for (const locY of locations) for (const locX of locations) {
+		if (map[locY][locX] !== null) continue;
+		for (let y = 0; y < 5; y++) for (let x = 0; x < 5; x++) map[locY - 2 + y][locX - 2 + x] = x === 0 || x === 4 || y === 0 || y === 4 || x === 2 && y === 2 ? 1 : 0;
+	}
+}
+function addTimingPatterns(map, size) {
+	const length = size - 16;
+	for (let i = 0; i < length; i++) {
+		const n = i % 2 === 0 ? 1 : 0;
+		map[6][8 + i] = n;
+		map[8 + i][6] = n;
+	}
+}
+function addDarkPattern(map, size) {
+	map[size - 8][8] = 1;
+}
+function addFormatInformationPatterns(map, size, fillBit) {
+	for (let i = 0; i < 15; i++) {
+		const bit = fillBit(14 - i);
+		map[8][i < 6 ? i : i < 7 ? i + 1 : size - 15 + i] = bit;
+		map[size - 1 - (i < 7 ? i : i < 9 ? size - 16 + i : size - 15 + i)][8] = bit;
+	}
+}
+function addVersionInformationPatterns(map, size, fillBit) {
+	for (let i = 0; i < 18; i++) {
+		map[size - 11 + i % 3][~~(i / 3)] = fillBit(i);
+		map[~~(i / 3)][size - 11 + ~~(i % 3)] = fillBit(i);
+	}
+}
+function placeDataBits(map, size, dataBits) {
+	const length = size * size;
+	let b = 0;
+	for (let i = 0; i < length; i++) {
+		const rest = ~~(i / 2) % size;
+		const quo = ~~(i / (size * 2));
+		const y = quo % 2 === 0 ? size - 1 - rest : rest;
+		let x = size - 2 - (quo * 2 - (i % 2 === 0 ? 1 : 0));
+		if (x < 7) x--;
+		if (map[y][x] === null) map[y][x] = dataBits[b++] + 2;
+	}
+}
+const maskModes = [
+	(row, col) => (row + col) % 2 === 0,
+	(row) => row % 2 === 0,
+	(_, col) => col % 3 === 0,
+	(row, col) => (row + col) % 3 === 0,
+	(row, col) => (~~(row / 2) + ~~(col / 3)) % 2 === 0,
+	(row, col) => row * col % 2 + row * col % 3 === 0,
+	(row, col) => (row * col % 2 + row * col % 3) % 2 === 0,
+	(row, col) => ((row + col) % 2 + row * col % 3) % 2 === 0
+];
+function getLeastFiveSameColoredPenalty(getEach, size) {
+	let score = 0;
+	for (let i = 0; i < size; i++) {
+		let sum = 0;
+		let last = -1;
+		for (let j = 0; j < size; j++) {
+			const bit = getEach(i, j);
+			if (sum === 0 || last === bit) {
+				sum++;
+				last = bit;
+			}
+			if (last !== bit || j === size - 1) {
+				if (sum >= 5) score += sum - 2;
+				sum = 1;
+				last = bit;
+			}
+		}
+	}
+	return score;
+}
+function getTwoByTwoSameColoredPenalty(map, size) {
+	let score = 0;
+	for (let y = 0; y < size - 2; y++) for (let x = 0; x < size - 2; x++) if ((map[y][x] + map[y][x + 1] + map[y + 1][x] + map[y + 1][x + 1]) % 4 === 0) score += 3;
+	return score;
+}
+function getFinderLikePenalty(map, size) {
+	let score = 0;
+	for (let i = 0; i < size - 11; i++) for (let j = 0; j < size - 11; j++) {
+		let rowBits = 0;
+		let colBits = 0;
+		for (let k = 0; k < 11; k++) {
+			rowBits = (rowBits << 1) + map[i][j + k];
+			colBits = (colBits << 1) + map[j + k][i];
+		}
+		if (rowBits === 1488 || rowBits === 93) score += 40;
+		if (colBits === 1488 || colBits === 93) score += 40;
+	}
+	return score;
+}
+function getBalancePenalty(map) {
+	const percent = map.reduce((sum, row) => sum + row.reduce((sum, bit) => sum + bit, 0), 0) / (map.length * map.length) * 100;
+	return Math.min(Math.abs(Math.floor(percent / 5) * 5 - 50) / 5, Math.abs(Math.ceil(percent / 5) * 5 - 50) / 5) * 10;
+}
+const errorCorrectionBit = [
+	1,
+	0,
+	3,
+	2
+];
+function getFormatInformationBits(eclIndex, maskNum) {
+	const ecMaskBits = errorCorrectionBit[eclIndex] << 3 | maskNum;
+	let rest = ecMaskBits;
+	for (let i = 0; i < 10; i++) rest = rest << 1 ^ (rest >>> 9) * 1335;
+	return (ecMaskBits << 10 | rest) ^ 21522;
+}
+function getVersionInformationBits(version) {
+	let rest = version;
+	for (let i = 0; i < 12; i++) rest = rest << 1 ^ (rest >>> 11) * 7973;
+	return version << 12 | rest;
+}
+const ECLList = [
+	"L",
+	"M",
+	"Q",
+	"H"
+];
+function qrcode(text, options = {}) {
+	const { ecl = "M" } = options;
+	let eclIndex = ECLList.indexOf(ecl);
+	if (eclIndex < 0) eclIndex = 1;
+	const mode = getMode(text);
+	const modeIndicator = getModeIndicator(mode);
+	let version = 0;
+	let size = 0;
+	let dataBits = [];
+	const groups = [];
+	let map = [];
+	let maskNum = 0;
+	let maskMap = [];
+	{
+		dataBits = encodeData(mode, text);
+		const codewords = dataBits.length / 8;
+		const charLength = mode === Mode.Byte ? codewords : text.length;
+		version = getVersion(mode, eclIndex, codewords);
+		size = getSize(version);
+		dataBits = [
+			...appendBits(modeIndicator, 4, []),
+			...appendBits(charLength, getCharCountIndicator(mode, version), []),
+			...dataBits
+		];
+		const rawDataBits = getRawDataCodewords(eclIndex, version) * 8;
+		appendBits(0, Math.min(rawDataBits - dataBits.length, 4), dataBits);
+		appendBits(0, (8 - dataBits.length % 8) % 8, dataBits);
+		for (let padByte = 236; dataBits.length < rawDataBits; padByte ^= 253) appendBits(padByte, 8, dataBits);
+	}
+	{
+		const codewords = [];
+		dataBits.forEach((bit, i) => {
+			codewords[i >> 3] |= bit << 7 - (i & 7);
+		});
+		const blocks = ECBlocks[eclIndex][version - 1];
+		const g2Blocks = ~~(getTotalDataModules(version) / 8) % blocks;
+		const g1Blocks = blocks - g2Blocks;
+		const totalDC = getRawDataCodewords(eclIndex, version);
+		const g1DCPerBlock = ~~(totalDC / blocks);
+		const g2DCPerBlock = g2Blocks === 0 ? 0 : (totalDC - g1DCPerBlock * g1Blocks) / g2Blocks;
+		const eccNum = ECCodewordsPerBlock[eclIndex][version - 1];
+		let currentIndex = 0;
+		for (const [blocks, DCPerBlock] of [[g1Blocks, g1DCPerBlock], [g2Blocks, g2DCPerBlock]]) for (let b = 0; b < blocks; b++) {
+			const dataCodewords = new Uint8Array(codewords.slice(currentIndex, currentIndex + DCPerBlock));
+			groups.push({
+				data: dataCodewords,
+				ecc: getECC(dataCodewords, eccNum)
+			});
+			currentIndex += DCPerBlock;
+		}
+	}
+	{
+		const dataCodewords = [];
+		const ecCodewords = [];
+		let i = 0;
+		while (true) {
+			if (groups.map((block) => {
+				const dataCodeWord = block.data[i];
+				if (dataCodeWord !== void 0) dataCodewords.push(dataCodeWord);
+				const ecCodeWord = block.ecc[i];
+				if (ecCodeWord !== void 0) ecCodewords.push(ecCodeWord);
+				return dataCodeWord === void 0 && ecCodeWord === void 0;
+			}).every((done) => done)) break;
+			i++;
+		}
+		const interleavedCodewords = dataCodewords.concat(ecCodewords);
+		dataBits = [];
+		interleavedCodewords.forEach((codewords) => {
+			appendBits(codewords, 8, dataBits);
+		});
+		appendBits(0, getTotalDataModules(version) - dataBits.length, dataBits);
+	}
+	map = Array(size).fill(null).map(() => Array(size).fill(null));
+	addFinderPatterns(map, size);
+	addSeparatorPatterns(map, size);
+	addAlignmentPatterns(map, version);
+	addTimingPatterns(map, size);
+	addDarkPattern(map, size);
+	addFormatInformationPatterns(map, size, () => 0);
+	if (version >= 7) addVersionInformationPatterns(map, size, () => 0);
+	placeDataBits(map, size, dataBits);
+	{
+		let lowerScore = Infinity;
+		for (let i = 0; i < 8; i++) {
+			const maskMode = maskModes[i];
+			const seedMap = map.map((row, rowIndex) => row.map((col, colIndex) => {
+				if (col < 2) return col;
+				col = col - 2;
+				return maskMode(rowIndex, colIndex) ? col ^ 1 : col;
+			}));
+			let score = 0;
+			score += getLeastFiveSameColoredPenalty((i, j) => seedMap[i][j], size);
+			score += getLeastFiveSameColoredPenalty((i, j) => seedMap[j][i], size);
+			score += getTwoByTwoSameColoredPenalty(seedMap, size);
+			score += getFinderLikePenalty(seedMap, size);
+			score += getBalancePenalty(seedMap);
+			if (score < lowerScore) {
+				lowerScore = score;
+				maskNum = i;
+				maskMap = seedMap;
+			}
+		}
+	}
+	{
+		const formatBits = getFormatInformationBits(eclIndex, maskNum);
+		addFormatInformationPatterns(map, size, (i) => formatBits >> i & 1);
+		if (version > 6) {
+			const versionBits = getVersionInformationBits(version);
+			addVersionInformationPatterns(map, size, (i) => versionBits >> i & 1);
+		}
+	}
+	maskMap.forEach((row, y) => {
+		row.forEach((col, x) => {
+			const mapCol = map[y][x];
+			if (mapCol !== 0 && mapCol !== 1) map[y][x] = col;
+		});
+	});
+	return map;
+}
+//#endregion
+export { ALPHANUMERIC_CHARS, ECLList, qrcode };