tessl/npm-crc

Comprehensive Cyclic Redundancy Check (CRC) calculation library supporting 13 different CRC algorithms for Node.js and browser environments.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

16-Bit CRC Algorithms

Name: tessl/npm-crc
Author: tessl

The CRC package provides five 16-bit CRC algorithms: CRC16, CRC16 CCITT, CRC16 Modbus, CRC16 XModem, and CRC16 Kermit. Each algorithm uses different polynomials and parameters optimized for specific protocols and applications.

Import

import { crc16, crc16ccitt, crc16modbus, crc16xmodem, crc16kermit } from "crc";
import crc16 from "crc/crc16";
import crc16ccitt from "crc/crc16ccitt";
import crc16modbus from "crc/crc16modbus";
import crc16xmodem from "crc/crc16xmodem";
import crc16kermit from "crc/crc16kermit";

// Raw calculators
import crc16Calculator from "crc/calculators/crc16";
import crc16ccittCalculator from "crc/calculators/crc16ccitt";
import crc16modbusCalculator from "crc/calculators/crc16modbus";
import crc16xmodemCalculator from "crc/calculators/crc16xmodem";
import crc16kermitCalculator from "crc/calculators/crc16kermit";

const { crc16, crc16ccitt, crc16modbus, crc16xmodem, crc16kermit } = require("crc");
const crc16 = require("crc/crc16");
const crc16ccitt = require("crc/crc16ccitt");
const crc16modbus = require("crc/crc16modbus");
const crc16xmodem = require("crc/crc16xmodem");
const crc16kermit = require("crc/crc16kermit");

// Raw calculators
const crc16Calculator = require("crc/calculators/crc16");
const crc16ccittCalculator = require("crc/calculators/crc16ccitt");
const crc16modbusCalculator = require("crc/calculators/crc16modbus");
const crc16xmodemCalculator = require("crc/calculators/crc16xmodem");
const crc16kermitCalculator = require("crc/calculators/crc16kermit");

API

CRC16 Standard

/**
 * Calculate standard CRC16 checksum
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC16 checksum as unsigned 16-bit number
 */
function crc16(value: BufferInput, previous?: number): number;

/**
 * CRC16 function with additional properties
 */
interface CRC16Module extends CRCModule {
  /** Returns signed CRC16 value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC16 value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "crc-16" */
  model: "crc-16";
}

CRC16 CCITT

/**
 * Calculate CRC16 CCITT checksum (commonly used in telecommunications)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC16 CCITT checksum as unsigned 16-bit number
 */
function crc16ccitt(value: BufferInput, previous?: number): number;

/**
 * CRC16 CCITT function with additional properties
 */
interface CRC16CCITTModule extends CRCModule {
  /** Returns signed CRC16 CCITT value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC16 CCITT value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "ccitt" */
  model: "ccitt";
}

CRC16 Modbus

/**
 * Calculate CRC16 Modbus checksum (used in Modbus protocol)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC16 Modbus checksum as unsigned 16-bit number
 */
function crc16modbus(value: BufferInput, previous?: number): number;

/**
 * CRC16 Modbus function with additional properties
 */
interface CRC16ModbusModule extends CRCModule {
  /** Returns signed CRC16 Modbus value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC16 Modbus value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "crc-16-modbus" */
  model: "crc-16-modbus";
}

CRC16 XModem

/**
 * Calculate CRC16 XModem checksum (used in XModem protocol)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC16 XModem checksum as unsigned 16-bit number
 */
function crc16xmodem(value: BufferInput, previous?: number): number;

/**
 * CRC16 XModem function with additional properties
 */
interface CRC16XModemModule extends CRCModule {
  /** Returns signed CRC16 XModem value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC16 XModem value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "xmodem" */
  model: "xmodem";
}

CRC16 Kermit

/**
 * Calculate CRC16 Kermit checksum (used in Kermit protocol)
 * @param value - Input data as string, ArrayBuffer, or Buffer
 * @param previous - Previous CRC value for incremental calculation (optional)
 * @returns CRC16 Kermit checksum as unsigned 16-bit number
 */
function crc16kermit(value: BufferInput, previous?: number): number;

/**
 * CRC16 Kermit function with additional properties
 */
interface CRC16KermitModule extends CRCModule {
  /** Returns signed CRC16 Kermit value */
  signed: (value: BufferInput, previous?: number) => number;
  /** Returns unsigned CRC16 Kermit value (same as main function) */
  unsigned: (value: BufferInput, previous?: number) => number;
  /** CRC model identifier: "kermit" */
  model: "kermit";
}

Raw Calculators

/**
 * Raw CRC16 calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC16 checksum as number
 */
function crc16Calculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRC16 CCITT calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC16 CCITT checksum as number
 */
function crc16ccittCalculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRC16 Modbus calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC16 Modbus checksum as number
 */
function crc16modbusCalculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRC16 XModem calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC16 XModem checksum as number
 */
function crc16xmodemCalculator(current: Uint8Array, previous?: number): number;

/**
 * Raw CRC16 Kermit calculator function for Uint8Array input
 * @param current - Input data as Uint8Array
 * @param previous - Previous CRC value for incremental calculation (optional, defaults to 0)
 * @returns CRC16 Kermit checksum as number
 */
function crc16kermitCalculator(current: Uint8Array, previous?: number): number;

Usage

Basic 16-Bit CRC Calculations

import { crc16, crc16ccitt, crc16modbus, crc16xmodem, crc16kermit } from "crc";

const data = "test data";

// Calculate different CRC16 variants
const standardCrc16 = crc16(data);
const ccittCrc16 = crc16ccitt(data);
const modbusCrc16 = crc16modbus(data);
const xmodemCrc16 = crc16xmodem(data);
const kermitCrc16 = crc16kermit(data);

console.log("CRC16:", standardCrc16.toString(16));
console.log("CRC16 CCITT:", ccittCrc16.toString(16));
console.log("CRC16 Modbus:", modbusCrc16.toString(16));
console.log("CRC16 XModem:", xmodemCrc16.toString(16));
console.log("CRC16 Kermit:", kermitCrc16.toString(16));

Protocol-Specific Usage

// Modbus RTU usage
import crc16modbus from "crc/crc16modbus";

const modbusFrame = Buffer.from([0x01, 0x03, 0x00, 0x00, 0x00, 0x02]);
const modbusCrc = crc16modbus(modbusFrame);
console.log("Modbus CRC:", modbusCrc.toString(16));

// Telecommunications (CCITT)
import crc16ccitt from "crc/crc16ccitt";

const telecomData = "HDLC frame data";
const ccittCrc = crc16ccitt(telecomData);
console.log("CCITT CRC:", ccittCrc.toString(16));

// File transfer protocols
import crc16xmodem from "crc/crc16xmodem";
import crc16kermit from "crc/crc16kermit";

const fileData = Buffer.from("file content chunk");
const xmodemCrc = crc16xmodem(fileData);
const kermitCrc = crc16kermit(fileData);
console.log("XModem CRC:", xmodemCrc.toString(16));
console.log("Kermit CRC:", kermitCrc.toString(16));

Incremental Calculation for Large Data

import crc16 from "crc/crc16";

// Process large file in chunks
let crcValue = crc16("first chunk");
crcValue = crc16("second chunk", crcValue);
crcValue = crc16("third chunk", crcValue);
crcValue = crc16("final chunk", crcValue);

console.log("Final CRC16:", crcValue.toString(16));

Performance Optimization

import crc16ccittCalculator from "crc/calculators/crc16ccitt";

// Use raw calculator for better performance
const encoder = new TextEncoder();
const data = encoder.encode("high-performance calculation");
const result = crc16ccittCalculator(data);

console.log("CRC16 CCITT result:", result.toString(16));

Data Integrity Verification

import crc16 from "crc/crc16";

// Calculate CRC for data integrity
const originalData = "important data";
const expectedCrc = crc16(originalData);

// Later, verify data integrity
const receivedData = "important data";
const receivedCrc = crc16(receivedData);

if (expectedCrc === receivedCrc) {
  console.log("Data integrity verified");
} else {
  console.log("Data corruption detected");
}

Signed vs Unsigned Results

import crc16ccitt from "crc/crc16ccitt";

const data = "test";

// Different result formats
const unsigned = crc16ccitt(data);           // 0-65535 range
const signed = crc16ccitt.signed(data);      // -32768 to 32767 range
const alsoUnsigned = crc16ccitt.unsigned(data); // Same as main function

console.log("Unsigned:", unsigned);
console.log("Signed:", signed);
console.log("Model:", crc16ccitt.model); // "crc-16-ccitt"

Multi-Input Type Support

import crc16modbus from "crc/crc16modbus";

// String input
const stringCrc = crc16modbus("hello");

// Buffer input (common for binary protocols)
const buffer = Buffer.from([0x01, 0x03, 0x00, 0x00, 0x00, 0x02]);
const bufferCrc = crc16modbus(buffer);

// ArrayBuffer input
const arrayBuffer = new ArrayBuffer(6);
const view = new Uint8Array(arrayBuffer);
view.set([0x01, 0x03, 0x00, 0x00, 0x00, 0x02]);
const arrayBufferCrc = crc16modbus(arrayBuffer);

console.log("String CRC:", stringCrc.toString(16));
console.log("Buffer CRC:", bufferCrc.toString(16));
console.log("ArrayBuffer CRC:", arrayBufferCrc.toString(16));

Algorithm Characteristics

CRC16 Standard

Polynomial: x^16 + x^15 + x^2 + 1
Use Case: General-purpose 16-bit error detection
Common Applications: Data storage, general communications

CRC16 CCITT

Polynomial: x^16 + x^12 + x^5 + 1
Use Case: Telecommunications and HDLC protocols
Common Applications: X.25, HDLC, Bluetooth, SD cards

CRC16 Modbus

Polynomial: x^16 + x^15 + x^2 + 1 (same as CRC16 but different parameters)
Use Case: Modbus RTU protocol
Common Applications: Industrial automation, SCADA systems

CRC16 XModem

Polynomial: x^16 + x^12 + x^5 + 1 (CCITT polynomial with different init)
Use Case: XModem file transfer protocol
Common Applications: Serial file transfers, embedded systems

CRC16 Kermit

Polynomial: x^16 + x^12 + x^5 + 1 (CCITT polynomial with byte swapping)
Use Case: Kermit file transfer protocol
Common Applications: Legacy file transfer systems

All 16-bit CRC algorithms provide excellent error detection capabilities and are widely used in networking, telecommunications, and data storage applications.