@robinpath/barcode - npm Package Compare versions

Comparing version

0.1.5

0.3.0

+20

dist/barcode.d.ts

		/**
		* RobinPath Barcode Module (Node port)
		*
		* Pure-JS QR code generator plus validators and converters for common linear
		* barcode formats: EAN-13, UPC-A, ISBN-10/13, and the Luhn checksum used by
		* credit card numbers and many ID schemes.
		*
		* No credentials, no network. The `configureBarcode(host)` hook is exposed for
		* parity with other modules but does nothing at runtime.
		*/
		import type { BuiltinHandler } from "@robinpath/core";
		type FunctionMetadata = Record<string, unknown>;
		type ModuleMetadata = Record<string, unknown>;
		type ModuleHost = unknown;
		export declare function configureBarcode(h: ModuleHost): void;
		export declare const BarcodeFunctions: Record<string, BuiltinHandler>;
		export declare const BarcodeFunctionMetadata: Record<string, FunctionMetadata>;
		export declare const BarcodeModuleMetadata: ModuleMetadata;
		export {};
		//# sourceMappingURL=barcode.d.ts.map

+1

dist/barcode.d.ts.map

{"version":3,"file":"barcode.d.ts","sourceRoot":"","sources":["../src/barcode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAOtD,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAChD,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC9C,KAAK,UAAU,GAAG,OAAO,CAAC;AAK1B,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI,CAEpD;AA2+BD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAe3D,CAAC;AAsDF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAsapE,CAAC;AAMF,eAAO,MAAM,qBAAqB,EAAE,cAsCnC,CAAC"}

+1406

dist/barcode.js

		/**
		* RobinPath Barcode Module (Node port)
		*
		* Pure-JS QR code generator plus validators and converters for common linear
		* barcode formats: EAN-13, UPC-A, ISBN-10/13, and the Luhn checksum used by
		* credit card numbers and many ID schemes.
		*
		* No credentials, no network. The `configureBarcode(host)` hook is exposed for
		* parity with other modules but does nothing at runtime.
		*/
		import { writeFileSync } from "node:fs";
		// ── Module-local state (configure hook kept for parity) ────────────────
		const state = {};
		export function configureBarcode(h) {
		state.host = h;
		}
		// ============================================================================
		// Pure JavaScript QR Code Encoder
		// Supports versions 1-10, error correction levels L/M/Q/H,
		// numeric, alphanumeric, and byte encoding modes.
		// ============================================================================
		const EC_LEVELS = { L: 0, M: 1, Q: 2, H: 3 };
		const MODE_NUMERIC = 0b0001;
		const MODE_ALPHANUMERIC = 0b0010;
		const MODE_BYTE = 0b0100;
		const ALPHANUM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
		const CHAR_COUNT_BITS = {
		[MODE_NUMERIC]: [10, 12, 14],
		[MODE_ALPHANUMERIC]: [9, 11, 13],
		[MODE_BYTE]: [8, 16, 16],
		};
		const TOTAL_CODEWORDS = [26, 44, 70, 100, 134, 172, 196, 242, 292, 346];
		// Per ISO/IEC 18004 Table 9
		const VERSION_EC_TABLE = [
		[[19, 7, 1, 19, 0, 0], [16, 10, 1, 16, 0, 0], [13, 13, 1, 13, 0, 0], [9, 17, 1, 9, 0, 0]],
		[[34, 10, 1, 34, 0, 0], [28, 16, 1, 28, 0, 0], [22, 22, 1, 22, 0, 0], [16, 28, 1, 16, 0, 0]],
		[[55, 15, 1, 55, 0, 0], [44, 26, 1, 44, 0, 0], [34, 18, 2, 17, 0, 0], [24, 22, 2, 12, 0, 0]],
		[[80, 20, 1, 80, 0, 0], [64, 18, 2, 32, 0, 0], [48, 26, 2, 24, 0, 0], [36, 16, 4, 9, 0, 0]],
		[[108, 26, 1, 108, 0, 0], [86, 24, 2, 43, 0, 0], [62, 18, 2, 15, 2, 16], [46, 22, 2, 11, 2, 12]],
		[[136, 18, 2, 68, 0, 0], [108, 16, 4, 27, 0, 0], [76, 24, 4, 19, 0, 0], [60, 28, 4, 15, 0, 0]],
		[[156, 20, 2, 78, 0, 0], [124, 18, 4, 31, 0, 0], [88, 18, 2, 14, 4, 15], [66, 26, 4, 13, 1, 14]],
		[[194, 24, 2, 97, 0, 0], [154, 22, 2, 38, 2, 39], [110, 22, 4, 18, 2, 19], [86, 26, 4, 14, 2, 15]],
		[[232, 30, 2, 116, 0, 0], [182, 22, 3, 36, 2, 37], [132, 20, 4, 16, 4, 17], [100, 24, 4, 12, 4, 13]],
		[[271, 18, 2, 68, 2, 69], [216, 26, 4, 43, 1, 44], [154, 24, 6, 19, 2, 20], [122, 28, 6, 15, 2, 16]],
		];
		const ALIGNMENT_POSITIONS = [
		[],
		[6, 18],
		[6, 22],
		[6, 26],
		[6, 30],
		[6, 34],
		[6, 22, 38],
		[6, 24, 42],
		[6, 26, 46],
		[6, 28, 50],
		];
		const FORMAT_INFO_STRINGS = [
		[0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976],
		[0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0],
		[0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed],
		[0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b],
		];
		// --- Reed-Solomon Error Correction (GF(256), poly 0x11d) ---
		const GF_EXP = new Uint8Array(512);
		const GF_LOG = new Uint8Array(256);
		(function initGaloisField() {
		let x = 1;
		for (let i = 0; i < 255; i++) {
		GF_EXP[i] = x;
		GF_LOG[x] = i;
		x <<= 1;
		if (x >= 256)
		x ^= 0x11d;
		}
		for (let i = 255; i < 512; i++) {
		GF_EXP[i] = GF_EXP[i - 255];
		}
		})();
		function gfMul(a, b) {
		if (a === 0 \|\| b === 0)
		return 0;
		return GF_EXP[GF_LOG[a] + GF_LOG[b]];
		}
		function rsGeneratorPoly(numECCodewords) {
		let gen = new Uint8Array([1]);
		for (let i = 0; i < numECCodewords; i++) {
		const newGen = new Uint8Array(gen.length + 1);
		for (let j = 0; j < gen.length; j++) {
		newGen[j] ^= gen[j];
		newGen[j + 1] ^= gfMul(gen[j], GF_EXP[i]);
		}
		gen = newGen;
		}
		return gen;
		}
		function rsEncode(data, numECCodewords) {
		const gen = rsGeneratorPoly(numECCodewords);
		const result = new Uint8Array(data.length + numECCodewords);
		result.set(data);
		for (let i = 0; i < data.length; i++) {
		const coef = result[i];
		if (coef !== 0) {
		for (let j = 0; j < gen.length; j++) {
		result[i + j] ^= gfMul(gen[j], coef);
		}
		}
		}
		return result.slice(data.length);
		}
		// --- Data Encoding ---
		function detectMode(text) {
		if (/^\d+$/.test(text))
		return MODE_NUMERIC;
		if (text.split("").every((c) => ALPHANUM_CHARS.includes(c)))
		return MODE_ALPHANUMERIC;
		return MODE_BYTE;
		}
		function getCharCountBits(mode, version) {
		const group = version <= 9 ? 0 : version <= 26 ? 1 : 2;
		return CHAR_COUNT_BITS[mode][group];
		}
		function getVersionECInfo(version, ecLevel) {
		const row = VERSION_EC_TABLE[version - 1][ecLevel];
		return {
		totalDataCodewords: row[0],
		ecCodewordsPerBlock: row[1],
		group1Blocks: row[2],
		group1DataCW: row[3],
		group2Blocks: row[4],
		group2DataCW: row[5],
		};
		}
		function selectVersion(text, mode, ecLevel) {
		const dataLen = mode === MODE_BYTE ? new TextEncoder().encode(text).length : text.length;
		for (let v = 1; v <= 10; v++) {
		const info = getVersionECInfo(v, ecLevel);
		const totalBits = info.totalDataCodewords * 8;
		const ccBits = getCharCountBits(mode, v);
		let dataBits;
		if (mode === MODE_NUMERIC) {
		dataBits =
		Math.floor(dataLen / 3) * 10 + (dataLen % 3 === 2 ? 7 : dataLen % 3 === 1 ? 4 : 0);
		}
		else if (mode === MODE_ALPHANUMERIC) {
		dataBits = Math.floor(dataLen / 2) * 11 + (dataLen % 2) * 6;
		}
		else {
		dataBits = dataLen * 8;
		}
		const needed = 4 + ccBits + dataBits;
		if (needed <= totalBits)
		return v;
		}
		throw new Error("Data too long for QR versions 1-10");
		}
		class BitBuffer {
		bits = [];
		get length() {
		return this.bits.length;
		}
		put(value, numBits) {
		for (let i = numBits - 1; i >= 0; i--) {
		this.bits.push((value >> i) & 1);
		}
		}
		getByte(index) {
		let byte = 0;
		for (let i = 0; i < 8; i++) {
		const bitIndex = index * 8 + i;
		if (bitIndex < this.bits.length) {
		byte = (byte << 1) \| this.bits[bitIndex];
		}
		else {
		byte <<= 1;
		}
		}
		return byte;
		}
		}
		function encodeData(text, version, ecLevel) {
		const mode = detectMode(text);
		const info = getVersionECInfo(version, ecLevel);
		const totalDataCodewords = info.totalDataCodewords;
		const buffer = new BitBuffer();
		buffer.put(mode, 4);
		const ccBits = getCharCountBits(mode, version);
		if (mode === MODE_NUMERIC) {
		buffer.put(text.length, ccBits);
		for (let i = 0; i < text.length; i += 3) {
		const group = text.substring(i, i + 3);
		const bits = group.length === 3 ? 10 : group.length === 2 ? 7 : 4;
		buffer.put(parseInt(group, 10), bits);
		}
		}
		else if (mode === MODE_ALPHANUMERIC) {
		buffer.put(text.length, ccBits);
		for (let i = 0; i < text.length; i += 2) {
		if (i + 1 < text.length) {
		const val = ALPHANUM_CHARS.indexOf(text[i]) * 45 + ALPHANUM_CHARS.indexOf(text[i + 1]);
		buffer.put(val, 11);
		}
		else {
		buffer.put(ALPHANUM_CHARS.indexOf(text[i]), 6);
		}
		}
		}
		else {
		const bytes = new TextEncoder().encode(text);
		buffer.put(bytes.length, ccBits);
		for (const b of bytes) {
		buffer.put(b, 8);
		}
		}
		const totalBits = totalDataCodewords * 8;
		const terminatorLen = Math.min(4, totalBits - buffer.length);
		buffer.put(0, terminatorLen);
		while (buffer.length % 8 !== 0) {
		buffer.put(0, 1);
		}
		const padPatterns = [0xec, 0x11];
		let padIdx = 0;
		while (buffer.length < totalBits) {
		buffer.put(padPatterns[padIdx], 8);
		padIdx = 1 - padIdx;
		}
		const data = new Uint8Array(totalDataCodewords);
		for (let i = 0; i < totalDataCodewords; i++) {
		data[i] = buffer.getByte(i);
		}
		return data;
		}
		// --- Error Correction & Interleaving ---
		function generateECCodewords(data, version, ecLevel) {
		const info = getVersionECInfo(version, ecLevel);
		const { ecCodewordsPerBlock, group1Blocks, group1DataCW, group2Blocks, group2DataCW } = info;
		const totalCodewords = TOTAL_CODEWORDS[version - 1];
		const dataBlocks = [];
		const ecBlocks = [];
		let offset = 0;
		for (let i = 0; i < group1Blocks; i++) {
		const block = data.slice(offset, offset + group1DataCW);
		dataBlocks.push(block);
		ecBlocks.push(rsEncode(block, ecCodewordsPerBlock));
		offset += group1DataCW;
		}
		for (let i = 0; i < group2Blocks; i++) {
		const block = data.slice(offset, offset + group2DataCW);
		dataBlocks.push(block);
		ecBlocks.push(rsEncode(block, ecCodewordsPerBlock));
		offset += group2DataCW;
		}
		const result = [];
		const maxDataCW = Math.max(group1DataCW, group2DataCW \|\| 0);
		for (let i = 0; i < maxDataCW; i++) {
		for (const block of dataBlocks) {
		if (i < block.length)
		result.push(block[i]);
		}
		}
		for (let i = 0; i < ecCodewordsPerBlock; i++) {
		for (const block of ecBlocks) {
		if (i < block.length)
		result.push(block[i]);
		}
		}
		const output = new Uint8Array(totalCodewords);
		for (let i = 0; i < Math.min(result.length, totalCodewords); i++) {
		output[i] = result[i];
		}
		return output;
		}
		// --- QR Matrix Construction ---
		function getModuleCount(version) {
		return version * 4 + 17;
		}
		function createMatrix(size) {
		return Array.from({ length: size }, () => Array(size).fill(null));
		}
		function placeFinderPattern(matrix, row, col) {
		for (let r = -1; r <= 7; r++) {
		for (let c = -1; c <= 7; c++) {
		const mr = row + r;
		const mc = col + c;
		if (mr < 0 \|\| mr >= matrix.length \|\| mc < 0 \|\| mc >= matrix.length)
		continue;
		if ((r >= 0 && r <= 6 && (c === 0 \|\| c === 6)) \|\|
		(c >= 0 && c <= 6 && (r === 0 \|\| r === 6)) \|\|
		(r >= 2 && r <= 4 && c >= 2 && c <= 4)) {
		matrix[mr][mc] = 1;
		}
		else {
		matrix[mr][mc] = 0;
		}
		}
		}
		}
		function placeAlignmentPattern(matrix, row, col) {
		for (let r = -2; r <= 2; r++) {
		for (let c = -2; c <= 2; c++) {
		if (Math.abs(r) === 2 \|\| Math.abs(c) === 2 \|\| (r === 0 && c === 0)) {
		matrix[row + r][col + c] = 1;
		}
		else {
		matrix[row + r][col + c] = 0;
		}
		}
		}
		}
		function placeTimingPatterns(matrix) {
		const size = matrix.length;
		for (let i = 8; i < size - 8; i++) {
		if (matrix[6][i] === null)
		matrix[6][i] = i % 2 === 0 ? 1 : 0;
		if (matrix[i][6] === null)
		matrix[i][6] = i % 2 === 0 ? 1 : 0;
		}
		}
		function reserveFormatInfo(matrix) {
		const size = matrix.length;
		for (let i = 0; i <= 8; i++) {
		if (matrix[8][i] === null)
		matrix[8][i] = 0;
		if (matrix[i][8] === null)
		matrix[i][8] = 0;
		}
		for (let i = 0; i <= 7; i++) {
		if (matrix[8][size - 1 - i] === null)
		matrix[8][size - 1 - i] = 0;
		}
		for (let i = 0; i <= 7; i++) {
		if (matrix[size - 1 - i][8] === null)
		matrix[size - 1 - i][8] = 0;
		}
		matrix[size - 8][8] = 1;
		}
		function placeAllPatterns(matrix, version) {
		const size = matrix.length;
		placeFinderPattern(matrix, 0, 0);
		placeFinderPattern(matrix, 0, size - 7);
		placeFinderPattern(matrix, size - 7, 0);
		if (version >= 2) {
		const positions = ALIGNMENT_POSITIONS[version - 1];
		for (const r of positions) {
		for (const c of positions) {
		if (r <= 8 && c <= 8)
		continue;
		if (r <= 8 && c >= size - 8)
		continue;
		if (r >= size - 8 && c <= 8)
		continue;
		placeAlignmentPattern(matrix, r, c);
		}
		}
		}
		placeTimingPatterns(matrix);
		reserveFormatInfo(matrix);
		}
		function placeData(matrix, data) {
		const size = matrix.length;
		let bitIndex = 0;
		const totalBits = data.length * 8;
		let col = size - 1;
		let goingUp = true;
		while (col >= 0) {
		if (col === 6)
		col--;
		for (let row = 0; row < size; row++) {
		const actualRow = goingUp ? size - 1 - row : row;
		for (let c = 0; c < 2; c++) {
		const actualCol = col - c;
		if (actualCol < 0)
		continue;
		if (matrix[actualRow][actualCol] !== null)
		continue;
		if (bitIndex < totalBits) {
		const byteIndex = Math.floor(bitIndex / 8);
		const bitOffset = 7 - (bitIndex % 8);
		matrix[actualRow][actualCol] = (data[byteIndex] >> bitOffset) & 1;
		bitIndex++;
		}
		else {
		matrix[actualRow][actualCol] = 0;
		}
		}
		}
		goingUp = !goingUp;
		col -= 2;
		}
		}
		// --- Masking ---
		function getMaskFunction(pattern) {
		switch (pattern) {
		case 0:
		return (r, c) => (r + c) % 2 === 0;
		case 1:
		return (r) => r % 2 === 0;
		case 2:
		return (_, c) => c % 3 === 0;
		case 3:
		return (r, c) => (r + c) % 3 === 0;
		case 4:
		return (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0;
		case 5:
		return (r, c) => ((r * c) % 2) + ((r * c) % 3) === 0;
		case 6:
		return (r, c) => (((r * c) % 2) + ((r * c) % 3)) % 2 === 0;
		case 7:
		return (r, c) => (((r + c) % 2) + ((r * c) % 3)) % 2 === 0;
		default:
		return (r, c) => (r + c) % 2 === 0;
		}
		}
		function isDataModule(patternMatrix, row, col) {
		return patternMatrix[row][col] === null;
		}
		function applyMask(matrix, patternMatrix, maskPattern) {
		const size = matrix.length;
		const masked = matrix.map((row) => [...row]);
		const maskFn = getMaskFunction(maskPattern);
		for (let r = 0; r < size; r++) {
		for (let c = 0; c < size; c++) {
		if (isDataModule(patternMatrix, r, c)) {
		if (maskFn(r, c)) {
		masked[r][c] = masked[r][c] === 1 ? 0 : 1;
		}
		}
		}
		}
		return masked;
		}
		function writeFormatInfo(matrix, ecLevel, maskPattern) {
		const size = matrix.length;
		const formatBits = FORMAT_INFO_STRINGS[ecLevel][maskPattern];
		const positions1 = [
		[8, 0], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 7], [8, 8],
		[7, 8], [5, 8], [4, 8], [3, 8], [2, 8], [1, 8], [0, 8],
		];
		const positions2 = [];
		for (let i = 0; i < 7; i++)
		positions2.push([size - 1 - i, 8]);
		for (let i = 0; i < 8; i++)
		positions2.push([8, size - 8 + i]);
		for (let i = 0; i < 15; i++) {
		const bit = (formatBits >> (14 - i)) & 1;
		const [r1, c1] = positions1[i];
		matrix[r1][c1] = bit;
		const [r2, c2] = positions2[i];
		matrix[r2][c2] = bit;
		}
		}
		function calculatePenalty(matrix) {
		const size = matrix.length;
		let penalty = 0;
		for (let r = 0; r < size; r++) {
		let count = 1;
		for (let c = 1; c < size; c++) {
		if (matrix[r][c] === matrix[r][c - 1]) {
		count++;
		if (c === size - 1 && count >= 5)
		penalty += count - 2;
		}
		else {
		if (count >= 5)
		penalty += count - 2;
		count = 1;
		}
		}
		}
		for (let c = 0; c < size; c++) {
		let count = 1;
		for (let r = 1; r < size; r++) {
		if (matrix[r][c] === matrix[r - 1][c]) {
		count++;
		if (r === size - 1 && count >= 5)
		penalty += count - 2;
		}
		else {
		if (count >= 5)
		penalty += count - 2;
		count = 1;
		}
		}
		}
		for (let r = 0; r < size - 1; r++) {
		for (let c = 0; c < size - 1; c++) {
		const val = matrix[r][c];
		if (val === matrix[r][c + 1] && val === matrix[r + 1][c] && val === matrix[r + 1][c + 1]) {
		penalty += 3;
		}
		}
		}
		for (let r = 0; r < size; r++) {
		for (let c = 0; c < size - 10; c++) {
		if (matrix[r][c] === 1 && matrix[r][c + 1] === 0 && matrix[r][c + 2] === 1 &&
		matrix[r][c + 3] === 1 && matrix[r][c + 4] === 1 && matrix[r][c + 5] === 0 &&
		matrix[r][c + 6] === 1 && matrix[r][c + 7] === 0 && matrix[r][c + 8] === 0 &&
		matrix[r][c + 9] === 0 && matrix[r][c + 10] === 0)
		penalty += 40;
		if (matrix[r][c] === 0 && matrix[r][c + 1] === 0 && matrix[r][c + 2] === 0 &&
		matrix[r][c + 3] === 0 && matrix[r][c + 4] === 1 && matrix[r][c + 5] === 0 &&
		matrix[r][c + 6] === 1 && matrix[r][c + 7] === 1 && matrix[r][c + 8] === 1 &&
		matrix[r][c + 9] === 0 && matrix[r][c + 10] === 1)
		penalty += 40;
		}
		}
		for (let c = 0; c < size; c++) {
		for (let r = 0; r < size - 10; r++) {
		if (matrix[r][c] === 1 && matrix[r + 1][c] === 0 && matrix[r + 2][c] === 1 &&
		matrix[r + 3][c] === 1 && matrix[r + 4][c] === 1 && matrix[r + 5][c] === 0 &&
		matrix[r + 6][c] === 1 && matrix[r + 7][c] === 0 && matrix[r + 8][c] === 0 &&
		matrix[r + 9][c] === 0 && matrix[r + 10][c] === 0)
		penalty += 40;
		if (matrix[r][c] === 0 && matrix[r + 1][c] === 0 && matrix[r + 2][c] === 0 &&
		matrix[r + 3][c] === 0 && matrix[r + 4][c] === 1 && matrix[r + 5][c] === 0 &&
		matrix[r + 6][c] === 1 && matrix[r + 7][c] === 1 && matrix[r + 8][c] === 1 &&
		matrix[r + 9][c] === 0 && matrix[r + 10][c] === 1)
		penalty += 40;
		}
		}
		let darkCount = 0;
		for (let r = 0; r < size; r++) {
		for (let c = 0; c < size; c++) {
		if (matrix[r][c] === 1)
		darkCount++;
		}
		}
		const percent = (darkCount / (size * size)) * 100;
		const prevFive = Math.floor(percent / 5) * 5;
		const nextFive = prevFive + 5;
		penalty += Math.min(Math.abs(prevFive - 50) / 5, Math.abs(nextFive - 50) / 5) * 10;
		return penalty;
		}
		function generateQRMatrix(text, ecLevelStr = "M") {
		const ecLevel = EC_LEVELS[ecLevelStr.toUpperCase()] ?? 1;
		const mode = detectMode(text);
		const version = selectVersion(text, mode, ecLevel);
		const size = getModuleCount(version);
		const data = encodeData(text, version, ecLevel);
		const codewords = generateECCodewords(data, version, ecLevel);
		const patternMatrix = createMatrix(size);
		placeAllPatterns(patternMatrix, version);
		const baseMatrix = createMatrix(size);
		placeAllPatterns(baseMatrix, version);
		placeData(baseMatrix, codewords);
		let bestMask = 0;
		let bestPenalty = Infinity;
		for (let mask = 0; mask < 8; mask++) {
		const masked = applyMask(baseMatrix, patternMatrix, mask);
		writeFormatInfo(masked, ecLevel, mask);
		const penalty = calculatePenalty(masked);
		if (penalty < bestPenalty) {
		bestPenalty = penalty;
		bestMask = mask;
		}
		}
		const finalMatrix = applyMask(baseMatrix, patternMatrix, bestMask);
		writeFormatInfo(finalMatrix, ecLevel, bestMask);
		return finalMatrix;
		}
		// --- Output Formats ---
		function matrixToSvg(matrix, opts = {}) {
		const moduleCount = matrix.length;
		const margin = opts.margin ?? 4;
		const width = opts.width ?? moduleCount + margin * 2;
		const darkColor = opts.darkColor ?? "#000000";
		const lightColor = opts.lightColor ?? "#ffffff";
		let svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${moduleCount + margin * 2} ${moduleCount + margin * 2}" width="${width}" height="${width}" shape-rendering="crispEdges">`;
		svg += `<rect width="100%" height="100%" fill="${lightColor}"/>`;
		for (let r = 0; r < moduleCount; r++) {
		for (let c = 0; c < moduleCount; c++) {
		if (matrix[r][c] === 1) {
		svg += `<rect x="${c + margin}" y="${r + margin}" width="1" height="1" fill="${darkColor}"/>`;
		}
		}
		}
		svg += "</svg>";
		return svg;
		}
		function matrixToTerminal(matrix) {
		const moduleCount = matrix.length;
		const margin = 2;
		const lines = [];
		const totalRows = moduleCount + margin * 2;
		const totalCols = moduleCount + margin * 2;
		const getModule = (r, c) => {
		const mr = r - margin;
		const mc = c - margin;
		if (mr < 0 \|\| mr >= moduleCount \|\| mc < 0 \|\| mc >= moduleCount)
		return false;
		return matrix[mr][mc] === 1;
		};
		for (let r = 0; r < totalRows; r += 2) {
		let line = "";
		for (let c = 0; c < totalCols; c++) {
		const top = getModule(r, c);
		const bottom = r + 1 < totalRows ? getModule(r + 1, c) : false;
		if (top && bottom)
		line += "\u2588";
		else if (top && !bottom)
		line += "\u2580";
		else if (!top && bottom)
		line += "\u2584";
		else
		line += " ";
		}
		lines.push(line);
		}
		return lines.join("\n");
		}
		// --- Minimal PNG encoder (uncompressed, no dependencies) ---
		function pngCrc32(data) {
		let crc = 0xffffffff;
		for (let i = 0; i < data.length; i++) {
		crc ^= data[i];
		for (let j = 0; j < 8; j++) {
		crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
		}
		}
		return (crc ^ 0xffffffff) >>> 0;
		}
		function adler32(data) {
		let a = 1;
		let b = 0;
		for (let i = 0; i < data.length; i++) {
		a = (a + data[i]) % 65521;
		b = (b + a) % 65521;
		}
		return ((b << 16) \| a) >>> 0;
		}
		function deflateStored(data) {
		const maxBlockSize = 65535;
		const numBlocks = Math.ceil(data.length / maxBlockSize) \|\| 1;
		const output = [];
		for (let i = 0; i < numBlocks; i++) {
		const start = i * maxBlockSize;
		const end = Math.min(start + maxBlockSize, data.length);
		const block = data.slice(start, end);
		const isLast = i === numBlocks - 1;
		output.push(isLast ? 0x01 : 0x00);
		const len = block.length;
		output.push(len & 0xff, (len >> 8) & 0xff);
		output.push(~len & 0xff, (~len >> 8) & 0xff);
		for (let j = 0; j < block.length; j++) {
		output.push(block[j]);
		}
		}
		return new Uint8Array(output);
		}
		function createZlibData(rawData) {
		const deflated = deflateStored(rawData);
		const adler = adler32(rawData);
		const result = new Uint8Array(2 + deflated.length + 4);
		result[0] = 0x78;
		result[1] = 0x01;
		result.set(deflated, 2);
		const off = 2 + deflated.length;
		result[off] = (adler >> 24) & 0xff;
		result[off + 1] = (adler >> 16) & 0xff;
		result[off + 2] = (adler >> 8) & 0xff;
		result[off + 3] = adler & 0xff;
		return result;
		}
		function pngChunk(type, data) {
		const typeBytes = new TextEncoder().encode(type);
		const chunk = new Uint8Array(4 + 4 + data.length + 4);
		const len = data.length;
		chunk[0] = (len >> 24) & 0xff;
		chunk[1] = (len >> 16) & 0xff;
		chunk[2] = (len >> 8) & 0xff;
		chunk[3] = len & 0xff;
		chunk.set(typeBytes, 4);
		chunk.set(data, 8);
		const crcData = new Uint8Array(4 + data.length);
		crcData.set(typeBytes, 0);
		crcData.set(data, 4);
		const crc = pngCrc32(crcData);
		chunk[8 + data.length] = (crc >> 24) & 0xff;
		chunk[9 + data.length] = (crc >> 16) & 0xff;
		chunk[10 + data.length] = (crc >> 8) & 0xff;
		chunk[11 + data.length] = crc & 0xff;
		return chunk;
		}
		function matrixToPng(matrix, opts = {}) {
		const moduleCount = matrix.length;
		const scale = opts.scale ?? 10;
		const margin = opts.margin ?? 4;
		const totalModules = moduleCount + margin * 2;
		const imgSize = totalModules * scale;
		const rawData = new Uint8Array((1 + imgSize) * imgSize);
		for (let py = 0; py < imgSize; py++) {
		const rowOffset = py * (1 + imgSize);
		rawData[rowOffset] = 0;
		const moduleRow = Math.floor(py / scale) - margin;
		for (let px = 0; px < imgSize; px++) {
		const moduleCol = Math.floor(px / scale) - margin;
		let isDark = false;
		if (moduleRow >= 0 && moduleRow < moduleCount && moduleCol >= 0 && moduleCol < moduleCount) {
		isDark = matrix[moduleRow][moduleCol] === 1;
		}
		rawData[rowOffset + 1 + px] = isDark ? 0 : 255;
		}
		}
		const PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
		const ihdr = new Uint8Array(13);
		ihdr[0] = (imgSize >> 24) & 0xff;
		ihdr[1] = (imgSize >> 16) & 0xff;
		ihdr[2] = (imgSize >> 8) & 0xff;
		ihdr[3] = imgSize & 0xff;
		ihdr[4] = (imgSize >> 24) & 0xff;
		ihdr[5] = (imgSize >> 16) & 0xff;
		ihdr[6] = (imgSize >> 8) & 0xff;
		ihdr[7] = imgSize & 0xff;
		ihdr[8] = 8;
		ihdr[9] = 0;
		ihdr[10] = 0;
		ihdr[11] = 0;
		ihdr[12] = 0;
		const compressedData = createZlibData(rawData);
		const iendData = new Uint8Array(0);
		const chunks = [
		PNG_SIGNATURE,
		pngChunk("IHDR", ihdr),
		pngChunk("IDAT", compressedData),
		pngChunk("IEND", iendData),
		];
		const totalLen = chunks.reduce((sum, c) => sum + c.length, 0);
		const png = new Uint8Array(totalLen);
		let offset = 0;
		for (const chunk of chunks) {
		png.set(chunk, offset);
		offset += chunk.length;
		}
		return png;
		}
		function uint8ArrayToBase64(bytes) {
		const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		let result = "";
		const len = bytes.length;
		for (let i = 0; i < len; i += 3) {
		const b0 = bytes[i];
		const b1 = i + 1 < len ? bytes[i + 1] : 0;
		const b2 = i + 2 < len ? bytes[i + 2] : 0;
		result += chars[(b0 >> 2) & 0x3f];
		result += chars[((b0 << 4) \| (b1 >> 4)) & 0x3f];
		result += i + 1 < len ? chars[((b1 << 2) \| (b2 >> 6)) & 0x3f] : "=";
		result += i + 2 < len ? chars[b2 & 0x3f] : "=";
		}
		return result;
		}
		function matrixToDataUrl(matrix, opts = {}) {
		const png = matrixToPng(matrix, opts);
		const base64 = uint8ArrayToBase64(png);
		return `data:image/png;base64,${base64}`;
		}
		function parseQROptions(opts) {
		if (typeof opts !== "object" \|\| opts === null)
		return {};
		return opts;
		}
		// ============================================================================
		// Handlers: QR generation
		// ============================================================================
		const qrGenerate = async (args) => {
		const text = String(args[0] ?? "");
		const opts = parseQROptions(args[1]);
		const ecLevel = opts.errorCorrectionLevel ?? "M";
		const matrix = generateQRMatrix(text, ecLevel);
		return matrixToDataUrl(matrix, { scale: opts.scale ?? 10, margin: opts.margin ?? 4 });
		};
		const qrToFile = async (args) => {
		const text = String(args[0] ?? "");
		const filePath = String(args[1] ?? "qr.svg");
		const opts = parseQROptions(args[2]);
		const ecLevel = opts.errorCorrectionLevel ?? "M";
		const matrix = generateQRMatrix(text, ecLevel);
		const svgWidth = opts.width ?? (matrix.length + (opts.margin ?? 4) * 2) * (opts.scale ?? 10);
		const svg = matrixToSvg(matrix, {
		width: svgWidth,
		margin: opts.margin ?? 4,
		darkColor: opts.color?.dark ?? "#000000",
		lightColor: opts.color?.light ?? "#ffffff",
		});
		writeFileSync(filePath, svg, "utf-8");
		return filePath;
		};
		const qrToSvg = async (args) => {
		const text = String(args[0] ?? "");
		const opts = parseQROptions(args[1]);
		const ecLevel = opts.errorCorrectionLevel ?? "M";
		const matrix = generateQRMatrix(text, ecLevel);
		return matrixToSvg(matrix, {
		margin: opts.margin ?? 4,
		darkColor: opts.color?.dark ?? "#000000",
		lightColor: opts.color?.light ?? "#ffffff",
		});
		};
		const qrToTerminal = async (args) => {
		const text = String(args[0] ?? "");
		const matrix = generateQRMatrix(text, "M");
		return matrixToTerminal(matrix);
		};
		// ============================================================================
		// Barcode validation / conversion helpers
		// ============================================================================
		function ean13Check(digits) {
		let sum = 0;
		for (let i = 0; i < 12; i++)
		sum += Number(digits[i]) * (i % 2 === 0 ? 1 : 3);
		return (10 - (sum % 10)) % 10;
		}
		const ean13Validate = async (args) => {
		const code = String(args[0] ?? "").replace(/\D/g, "");
		if (code.length !== 13)
		return false;
		return ean13Check(code) === Number(code[12]);
		};
		const ean13Checksum = async (args) => {
		const code = String(args[0] ?? "").replace(/\D/g, "");
		if (code.length < 12)
		return null;
		return String(ean13Check(code));
		};
		const upcValidate = async (args) => {
		const code = String(args[0] ?? "").replace(/\D/g, "");
		if (code.length !== 12)
		return false;
		return ean13Check("0" + code) === Number(code[11]);
		};
		const upcChecksum = async (args) => {
		const code = String(args[0] ?? "").replace(/\D/g, "");
		if (code.length < 11)
		return null;
		return String(ean13Check("0" + code));
		};
		const isbn10Validate = async (args) => {
		const isbn = String(args[0] ?? "").replace(/[-\s]/g, "");
		if (isbn.length !== 10)
		return false;
		let sum = 0;
		for (let i = 0; i < 10; i++) {
		const c = isbn[i];
		const val = c === "X" \|\| c === "x" ? 10 : Number(c);
		if (isNaN(val))
		return false;
		sum += val * (10 - i);
		}
		return sum % 11 === 0;
		};
		const isbn13Validate = async (args) => {
		const code = String(args[0] ?? "").replace(/\D/g, "");
		if (code.length !== 13)
		return false;
		return ean13Check(code) === Number(code[12]);
		};
		const isbn10to13 = async (args) => {
		const isbn = String(args[0] ?? "").replace(/[-\s]/g, "");
		if (isbn.length !== 10)
		return null;
		const base = "978" + isbn.substring(0, 9);
		return base + String(ean13Check(base));
		};
		const isbn13to10 = async (args) => {
		const isbn = String(args[0] ?? "").replace(/[-\s]/g, "");
		if (isbn.length !== 13 \|\| !isbn.startsWith("978"))
		return null;
		const base = isbn.substring(3, 12);
		let sum = 0;
		for (let i = 0; i < 9; i++)
		sum += Number(base[i]) * (10 - i);
		const check = (11 - (sum % 11)) % 11;
		return base + (check === 10 ? "X" : String(check));
		};
		function luhnCheck(num) {
		let sum = 0;
		let alt = false;
		for (let i = num.length - 1; i >= 0; i--) {
		let n = Number(num[i]);
		if (alt) {
		n *= 2;
		if (n > 9)
		n -= 9;
		}
		sum += n;
		alt = !alt;
		}
		return sum % 10 === 0;
		}
		const luhn = async (args) => {
		const num = String(args[0] ?? "").replace(/\D/g, "");
		return luhnCheck(num);
		};
		const luhnGenerate = async (args) => {
		const num = String(args[0] ?? "").replace(/\D/g, "");
		for (let d = 0; d <= 9; d++) {
		if (luhnCheck(num + String(d)))
		return num + String(d);
		}
		return num + "0";
		};
		// ============================================================================
		// Exports: functions map
		// ============================================================================
		export const BarcodeFunctions = {
		qrGenerate,
		qrToFile,
		qrToSvg,
		qrToTerminal,
		ean13Validate,
		ean13Checksum,
		upcValidate,
		upcChecksum,
		isbn10Validate,
		isbn13Validate,
		isbn10to13,
		isbn13to10,
		luhn,
		luhnGenerate,
		};
		// ── Shared parameter descriptors ────────────────────────────────────────
		const qrTextParam = {
		name: "text",
		title: "Text",
		description: "The string to encode into the QR code. URLs, vCards, and arbitrary text are supported.",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "https://example.com",
		};
		const qrOptionsParam = {
		name: "options",
		title: "Options",
		description: "Optional QR render settings: `scale` (pixels per module), `margin` (quiet zone modules), `errorCorrectionLevel` ('L' \| 'M' \| 'Q' \| 'H'), and `color: {dark, light}`.",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		placeholder: '{"scale": 10, "errorCorrectionLevel": "M"}',
		};
		const codeStringParam = {
		name: "code",
		title: "Code",
		description: "The barcode digits (any non-digit characters are stripped before validation).",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "4006381333931",
		};
		const isbnParam = {
		name: "isbn",
		title: "ISBN",
		description: "ISBN string (dashes and spaces are removed automatically).",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "978-0-306-40615-7",
		};
		// ============================================================================
		// Exports: function metadata
		// ============================================================================
		export const BarcodeFunctionMetadata = {
		qrGenerate: {
		title: "Generate QR code (PNG data URL)",
		summary: "Encode text as a QR code and return a PNG data URL",
		description: "Encodes the input text as a QR code matrix and renders it as a base64 `data:image/png;base64,...` string. Pure JavaScript implementation — supports QR versions 1–10 with error correction levels L/M/Q/H.",
		group: "qr",
		action: "read",
		icon: "qr-code",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "qr", "encode", "image"],
		parameters: [qrTextParam, qrOptionsParam],
		returnType: "string",
		returnDescription: "`data:image/png;base64,...` URL encoding the QR code.",
		errors: {
		data_too_long: "Input exceeds QR version 10 capacity.",
		},
		examples: [
		{
		title: "Encode a URL",
		code: 'barcode.qrGenerate "https://example.com"',
		},
		],
		example: 'barcode.qrGenerate "https://example.com"',
		},
		qrToFile: {
		title: "Generate QR code to SVG file",
		summary: "Write a QR code as an SVG file",
		description: "Encodes the input text and writes the resulting QR code to disk as a scalable SVG.",
		group: "qr",
		action: "write",
		icon: "file-image",
		capability: "write",
		sideEffects: ["file_write"],
		idempotent: false,
		since: "1.0.0",
		tags: ["barcode", "qr", "svg", "file"],
		parameters: [
		qrTextParam,
		{
		name: "filePath",
		title: "Output path",
		description: "Filesystem path for the resulting SVG file.",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "./qr.svg",
		},
		qrOptionsParam,
		],
		returnType: "string",
		returnDescription: "Path to the written SVG file.",
		errors: {
		data_too_long: "Input exceeds QR version 10 capacity.",
		write_failed: "Output file could not be written.",
		},
		examples: [
		{
		title: "Save a QR for a URL",
		code: 'barcode.qrToFile "https://example.com" "./qr.svg"',
		},
		],
		example: 'barcode.qrToFile "https://example.com" "./qr.svg"',
		},
		qrToSvg: {
		title: "Generate QR code as SVG",
		summary: "Return a QR code as an SVG string",
		description: "Encodes the input text as a QR code and returns it as an inline SVG string.",
		group: "qr",
		action: "read",
		icon: "code",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "qr", "svg"],
		parameters: [qrTextParam, qrOptionsParam],
		returnType: "string",
		returnDescription: "SVG markup containing the QR code.",
		errors: {
		data_too_long: "Input exceeds QR version 10 capacity.",
		},
		examples: [
		{
		title: "Get inline SVG",
		code: 'barcode.qrToSvg "hello"',
		},
		],
		example: 'barcode.qrToSvg "hello"',
		},
		qrToTerminal: {
		title: "Generate QR code for terminal",
		summary: "Render a QR code using Unicode block characters",
		description: "Encodes the input text and renders the QR using half-block Unicode characters so it is directly scannable from a terminal.",
		group: "qr",
		action: "read",
		icon: "terminal",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "qr", "terminal", "text"],
		parameters: [qrTextParam],
		returnType: "string",
		returnDescription: "Multi-line string suitable for printing to a monospace terminal.",
		errors: {
		data_too_long: "Input exceeds QR version 10 capacity.",
		},
		examples: [
		{
		title: "Print a QR in the console",
		code: 'barcode.qrToTerminal "hello"',
		},
		],
		example: 'barcode.qrToTerminal "hello"',
		},
		ean13Validate: {
		title: "Validate EAN-13",
		summary: "Verify an EAN-13 barcode check digit",
		description: "Returns `true` if the 13-digit EAN code has a valid check digit.",
		group: "linear",
		action: "read",
		icon: "scan-barcode",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "ean", "validate"],
		parameters: [codeStringParam],
		returnType: "boolean",
		returnDescription: "`true` when the check digit is correct.",
		errors: {},
		examples: [
		{
		title: "Check an EAN-13",
		code: 'barcode.ean13Validate "4006381333931"',
		},
		],
		example: 'barcode.ean13Validate "4006381333931"',
		},
		ean13Checksum: {
		title: "EAN-13 check digit",
		summary: "Compute the EAN-13 check digit for a 12-digit base",
		description: "Returns the check digit for a 12-digit EAN-13 base code, or `null` if fewer than 12 digits are supplied.",
		group: "linear",
		action: "read",
		icon: "hash",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "ean", "checksum"],
		parameters: [
		{
		...codeStringParam,
		description: "The 12 leading digits of an EAN-13 code (without the check digit).",
		placeholder: "400638133393",
		},
		],
		returnType: "string",
		returnDescription: "Single-digit string, or `null` if input is too short.",
		errors: {},
		examples: [
		{
		title: "Compute check digit",
		code: 'barcode.ean13Checksum "400638133393"',
		},
		],
		example: 'barcode.ean13Checksum "400638133393"',
		},
		upcValidate: {
		title: "Validate UPC-A",
		summary: "Verify a UPC-A barcode check digit",
		description: "Returns `true` if the 12-digit UPC-A code has a valid check digit.",
		group: "linear",
		action: "read",
		icon: "scan-barcode",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "upc", "validate"],
		parameters: [
		{
		...codeStringParam,
		description: "The 12-digit UPC-A code.",
		placeholder: "012345678905",
		},
		],
		returnType: "boolean",
		returnDescription: "`true` when the check digit is correct.",
		errors: {},
		examples: [
		{
		title: "Check a UPC-A",
		code: 'barcode.upcValidate "012345678905"',
		},
		],
		example: 'barcode.upcValidate "012345678905"',
		},
		upcChecksum: {
		title: "UPC-A check digit",
		summary: "Compute the UPC-A check digit for an 11-digit base",
		description: "Returns the check digit for an 11-digit UPC-A base code, or `null` if fewer than 11 digits are supplied.",
		group: "linear",
		action: "read",
		icon: "hash",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "upc", "checksum"],
		parameters: [
		{
		...codeStringParam,
		description: "The 11 leading digits of a UPC-A code.",
		placeholder: "01234567890",
		},
		],
		returnType: "string",
		returnDescription: "Single-digit string, or `null` if input is too short.",
		errors: {},
		examples: [
		{
		title: "Compute check digit",
		code: 'barcode.upcChecksum "01234567890"',
		},
		],
		example: 'barcode.upcChecksum "01234567890"',
		},
		isbn10Validate: {
		title: "Validate ISBN-10",
		summary: "Verify an ISBN-10 check digit",
		description: "Returns `true` if the 10-character ISBN has a valid check digit. Terminal 'X' is treated as 10.",
		group: "isbn",
		action: "read",
		icon: "book",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "isbn", "validate"],
		parameters: [{ ...isbnParam, placeholder: "0-306-40615-2" }],
		returnType: "boolean",
		returnDescription: "`true` when the check digit is correct.",
		errors: {},
		examples: [
		{
		title: "Check an ISBN-10",
		code: 'barcode.isbn10Validate "0-306-40615-2"',
		},
		],
		example: 'barcode.isbn10Validate "0-306-40615-2"',
		},
		isbn13Validate: {
		title: "Validate ISBN-13",
		summary: "Verify an ISBN-13 check digit",
		description: "Returns `true` if the 13-digit ISBN has a valid check digit (same rules as EAN-13).",
		group: "isbn",
		action: "read",
		icon: "book",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "isbn", "validate"],
		parameters: [isbnParam],
		returnType: "boolean",
		returnDescription: "`true` when the check digit is correct.",
		errors: {},
		examples: [
		{
		title: "Check an ISBN-13",
		code: 'barcode.isbn13Validate "978-0-306-40615-7"',
		},
		],
		example: 'barcode.isbn13Validate "978-0-306-40615-7"',
		},
		isbn10to13: {
		title: "Convert ISBN-10 to ISBN-13",
		summary: "Upgrade an ISBN-10 to ISBN-13",
		description: "Prepends the `978` prefix and computes a new check digit to produce an ISBN-13. Returns `null` if the input is not 10 digits.",
		group: "isbn",
		action: "read",
		icon: "arrow-right",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "isbn", "convert"],
		parameters: [{ ...isbnParam, placeholder: "0306406152" }],
		returnType: "string",
		returnDescription: "The equivalent ISBN-13, or `null` if the input is invalid.",
		errors: {},
		examples: [
		{
		title: "Upgrade ISBN-10",
		code: 'barcode.isbn10to13 "0306406152"',
		},
		],
		example: 'barcode.isbn10to13 "0306406152"',
		},
		isbn13to10: {
		title: "Convert ISBN-13 to ISBN-10",
		summary: "Downgrade a `978`-prefixed ISBN-13 to ISBN-10",
		description: "Drops the `978` prefix and recomputes the ISBN-10 check digit. Returns `null` if the input is not a `978`-prefixed ISBN-13.",
		group: "isbn",
		action: "read",
		icon: "arrow-left",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "isbn", "convert"],
		parameters: [isbnParam],
		returnType: "string",
		returnDescription: "The equivalent ISBN-10, or `null` if the ISBN-13 is not convertible.",
		errors: {},
		examples: [
		{
		title: "Downgrade ISBN-13",
		code: 'barcode.isbn13to10 "9780306406157"',
		},
		],
		example: 'barcode.isbn13to10 "9780306406157"',
		},
		luhn: {
		title: "Validate Luhn checksum",
		summary: "Check a number against the Luhn mod-10 algorithm",
		description: "Validates a numeric string using the Luhn algorithm — the standard check used by credit card numbers, IMEI, and other identifiers.",
		group: "luhn",
		action: "read",
		icon: "credit-card",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "luhn", "validate", "credit-card"],
		parameters: [
		{
		name: "number",
		title: "Number",
		description: "Digit string to validate (non-digits are stripped).",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "4539578763621486",
		},
		],
		returnType: "boolean",
		returnDescription: "`true` when the Luhn check passes.",
		errors: {},
		examples: [
		{
		title: "Validate a credit card number",
		code: 'barcode.luhn "4539578763621486"',
		},
		],
		example: 'barcode.luhn "4539578763621486"',
		},
		luhnGenerate: {
		title: "Generate Luhn check digit",
		summary: "Compute the Luhn check digit for a numeric base",
		description: "Finds the check digit that makes the resulting number valid under the Luhn mod-10 algorithm and returns the full number (base + check digit).",
		group: "luhn",
		action: "read",
		icon: "hash",
		capability: "read",
		sideEffects: [],
		idempotent: true,
		since: "1.0.0",
		tags: ["barcode", "luhn", "generate"],
		parameters: [
		{
		name: "number",
		title: "Base number",
		description: "Digit string without its final check digit.",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "453957876362148",
		},
		],
		returnType: "string",
		returnDescription: "Input with a valid Luhn check digit appended.",
		errors: {},
		examples: [
		{
		title: "Compute the check digit",
		code: 'barcode.luhnGenerate "453957876362148"',
		},
		],
		example: 'barcode.luhnGenerate "453957876362148"',
		},
		};
		// ============================================================================
		// Exports: module metadata
		// ============================================================================
		export const BarcodeModuleMetadata = {
		slug: "barcode",
		title: "Barcode",
		summary: "QR code generation and EAN/UPC/ISBN/Luhn validators",
		description: "Pure-JS QR code generator (versions 1–10, EC levels L/M/Q/H, PNG data URL or SVG output) plus validators and converters for common linear barcode formats: EAN-13, UPC-A, ISBN-10/13, and the Luhn checksum used by credit card numbers.\n\nNo network dependencies — everything runs locally.",
		category: "utility",
		icon: "icon.svg",
		color: "#0ea5e9",
		version: "0.2.0",
		docsUrl: "https://docs.robinpath.com/modules/barcode",
		status: "stable",
		requires: [],
		minNodeVersion: "18.0.0",
		credentialsType: null,
		operationGroups: {
		qr: {
		title: "QR codes",
		description: "Encode text as QR codes (PNG, SVG, or terminal output).",
		order: 1,
		},
		linear: {
		title: "EAN / UPC",
		description: "Linear barcode validation and check-digit computation.",
		order: 2,
		},
		isbn: {
		title: "ISBN",
		description: "Validate and convert ISBN-10 / ISBN-13 identifiers.",
		order: 3,
		},
		luhn: {
		title: "Luhn",
		description: "Luhn mod-10 checksum validation and generation.",
		order: 4,
		},
		},
		methods: Object.keys(BarcodeFunctions),
		};
		//# sourceMappingURL=barcode.js.map

+1

dist/barcode.js.map

+6

dist/index.d.ts

		import type { ModuleAdapter } from "@robinpath/core";
		declare const BarcodeModule: ModuleAdapter;
		export default BarcodeModule;
		export { BarcodeModule };
		export { BarcodeFunctions, BarcodeFunctionMetadata, BarcodeModuleMetadata, configureBarcode, } from "./barcode.js";
		//# sourceMappingURL=index.d.ts.map

+1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAWrD,QAAA,MAAM,aAAa,EAAE,aASQ,CAAC;AAE9B,eAAe,aAAa,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,cAAc,CAAC"}

+18

dist/index.js

		import { BarcodeFunctions, BarcodeFunctionMetadata, BarcodeModuleMetadata, configureBarcode, } from "./barcode.js";
		// `credentialTypes` and `configure` are fields on newer `@robinpath/core`
		// `ModuleAdapter` releases; cast through `unknown` so this file compiles
		// against older installed cores too.
		const BarcodeModule = {
		name: "barcode",
		functions: BarcodeFunctions,
		functionMetadata: BarcodeFunctionMetadata,
		moduleMetadata: BarcodeModuleMetadata,
		// No credentials — pure local QR/barcode utility.
		credentialTypes: [],
		configure: configureBarcode,
		global: false,
		};
		export default BarcodeModule;
		export { BarcodeModule };
		export { BarcodeFunctions, BarcodeFunctionMetadata, BarcodeModuleMetadata, configureBarcode, } from "./barcode.js";
		//# sourceMappingURL=index.js.map

+1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AAEtB,0EAA0E;AAC1E,yEAAyE;AACzE,qCAAqC;AACrC,MAAM,aAAa,GAAkB;IACnC,IAAI,EAAE,SAAS;IACf,SAAS,EAAE,gBAAgB;IAC3B,gBAAgB,EAAE,uBAAuE;IACzF,cAAc,EAAE,qBAAmE;IACnF,kDAAkD;IAClD,eAAe,EAAE,EAAE;IACnB,SAAS,EAAE,gBAAgB;IAC3B,MAAM,EAAE,KAAK;CACc,CAAC;AAE9B,eAAe,aAAa,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,cAAc,CAAC"}

+9

-4

package.json

		{
		"name": "@robinpath/barcode",
		"version": "0.1.5",
		"version": "0.3.0",
		"publishConfig": {
		@@ -24,6 +24,6 @@ "access": "public"
		"peerDependencies": {
		"@robinpath/core": ">=0.20.0"
		"@robinpath/core": ">=0.40.0"
		},
		"devDependencies": {
		"@robinpath/core": "^0.30.1",
		"@robinpath/core": "^0.40.0",
		"tsx": "^4.19.0",
		@@ -42,4 +42,9 @@ "typescript": "^5.6.0"
		"auth": "none",
		"functionCount": 14
		"functionCount": 14,
		"language": "nodejs",
		"platforms": [
		"cloud",
		"cli"
		]
		}
		}

+1

-1

README.md

		@@ -22,3 +22,3 @@ # @robinpath/barcode
		```bash
		npm install @robinpath/barcode
		robinpath add @robinpath/barcode
		```
		@@ -25,0 +25,0 @@

@robinpath/barcode - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics