@zxing/library

import {
  MultiFormatReader,
  BinaryBitmap,
  HybridBinarizer,
  RGBLuminanceSource
} from '@zxing/library';

const luminanceSource = new RGBLuminanceSource(imagePixels, width, height);
const binaryBitmap = new BinaryBitmap(new HybridBinarizer(luminanceSource));
const reader = new MultiFormatReader();

try {
  const result = reader.decode(binaryBitmap);
  console.log('Decoded:', result.getText());
  console.log('Format:', result.getBarcodeFormat());
} catch (error) {
  console.error('No barcode found:', error);
}

import {
  QRCodeWriter,
  BarcodeFormat,
  EncodeHintType,
  QRCodeDecoderErrorCorrectionLevel
} from '@zxing/library';

const writer = new QRCodeWriter();
const hints = new Map();
hints.set(EncodeHintType.ERROR_CORRECTION, QRCodeDecoderErrorCorrectionLevel.H);

const bitMatrix = writer.encode(
  'https://example.com',
  BarcodeFormat.QR_CODE,
  300,
  300,
  hints
);

// Render: matrix.get(x, y) returns true for black pixels

import { BrowserMultiFormatReader } from '@zxing/library';

const codeReader = new BrowserMultiFormatReader();
const videoElement = document.getElementById('video') as HTMLVideoElement;

const result = await codeReader.decodeOnceFromVideoDevice(undefined, videoElement);
console.log('Scanned:', result.getText());
codeReader.reset(); // Release camera

class MultiFormatReader implements Reader {
  decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
  decodeWithState(image: BinaryBitmap): Result;
  setHints(hints: Map<DecodeHintType, any> | null): void;
  reset(): void;
}

class QRCodeReader implements Reader {
  decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
  reset(): void;
}

class DataMatrixReader implements Reader {
  decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
  reset(): void;
}

class AztecCodeReader implements Reader {
  decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
  reset(): void;
}

class PDF417Reader implements Reader, MultipleBarcodeReader {
  decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
  decodeMultiple(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result[];
  reset(): void;
}

class MultiFormatWriter implements Writer {
  encode(
    contents: string,
    format: BarcodeFormat,
    width: number,
    height: number,
    hints: Map<EncodeHintType, any>
  ): BitMatrix;
}

class QRCodeWriter implements Writer {
  encode(
    contents: string,
    format: BarcodeFormat,
    width: number,
    height: number,
    hints?: Map<EncodeHintType, any>
  ): BitMatrix;
}

class DataMatrixWriter implements Writer {
  encode(
    contents: string,
    format: BarcodeFormat,
    width: number,
    height: number,
    hints?: Map<EncodeHintType, any>
  ): BitMatrix;
}

class AztecCodeWriter implements Writer {
  encode(
    contents: string,
    format: BarcodeFormat,
    width: number,
    height: number,
    hints?: Map<EncodeHintType, any>
  ): BitMatrix;
}

class BinaryBitmap {
  constructor(binarizer: Binarizer);
  getWidth(): number;
  getHeight(): number;
  getBlackRow(y: number, row: BitArray | null): BitArray;
  getBlackMatrix(): BitMatrix;
  isCropSupported(): boolean;
  crop(left: number, top: number, width: number, height: number): BinaryBitmap;
}

abstract class LuminanceSource {
  abstract getRow(y: number, row?: Uint8ClampedArray): Uint8ClampedArray;
  abstract getMatrix(): Uint8ClampedArray;
  abstract invert(): LuminanceSource;
  getWidth(): number;
  getHeight(): number;
}

class RGBLuminanceSource extends LuminanceSource {
  constructor(
    luminances: Uint8ClampedArray | Int32Array,
    width: number,
    height: number,
    dataWidth?: number,
    dataHeight?: number,
    left?: number,
    top?: number
  );
}

class HybridBinarizer extends Binarizer {
  constructor(source: LuminanceSource);
}

class Result {
  constructor(
    text: string,
    rawBytes: Uint8Array | null,
    numBits: number,
    resultPoints: ResultPoint[],
    format: BarcodeFormat,
    timestamp: number
  );
  getText(): string;
  getRawBytes(): Uint8Array | null;
  getBarcodeFormat(): BarcodeFormat;
  getResultMetadata(): Map<ResultMetadataType, Object>;
  getResultPoints(): ResultPoint[];
}

try {
  const result = reader.decode(bitmap);
} catch (error) {
  if (error instanceof NotFoundException) {
    // No barcode found
  } else if (error instanceof ChecksumException) {
    // Barcode damaged
  }
}

const hints = new Map();

// Limit to specific formats (improves performance)
hints.set(DecodeHintType.POSSIBLE_FORMATS, [
  BarcodeFormat.QR_CODE,
  BarcodeFormat.EAN_13
]);

// Enable accuracy mode
  hints.set(DecodeHintType.TRY_HARDER, true);
  
// Specify character encoding
hints.set(DecodeHintType.CHARACTER_SET, 'UTF-8');

// Pure barcode image (no detection needed, faster)
hints.set(DecodeHintType.PURE_BARCODE, true);

const hints = new Map();

// QR Code: Set error correction level
hints.set(EncodeHintType.ERROR_CORRECTION, 'H'); // L, M, Q, or H

// Set character encoding
hints.set(EncodeHintType.CHARACTER_SET, 'UTF-8');

// Set margin/quiet zone
hints.set(EncodeHintType.MARGIN, 4); // In modules

// QR Code: Force specific version
hints.set(EncodeHintType.QR_VERSION, 10); // 1-40

// Aztec: Set layer count
hints.set(EncodeHintType.AZTEC_LAYERS, 0); // 0=auto, negative=compact, positive=full

// Data Matrix: Force square shape
hints.set(EncodeHintType.DATA_MATRIX_SHAPE, SymbolShapeHint.FORCE_SQUARE);

// Recommended (more accurate)
const binarizer = new HybridBinarizer(luminanceSource);

// Faster alternative
const binarizer = new GlobalHistogramBinarizer(luminanceSource);

import {
  NotFoundException,
  FormatException,
  ChecksumException,
  WriterException
} from '@zxing/library';

try {
  const result = reader.decode(bitmap);
  // Success
  } catch (error) {
  if (error instanceof NotFoundException) {
    // No barcode found - check image quality
  } else if (error instanceof ChecksumException) {
    // Barcode damaged - retry with TRY_HARDER
  } else if (error instanceof FormatException) {
    // Invalid barcode structure
  } else if (error instanceof WriterException) {
    // Encoding failed - check data size/format compatibility
  }
}