or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

advanced-classes.mdcore-operations.mdextensions.mdindex.mditerators.mdstreaming.md
tile.json

tessl/npm-msgpackr

Ultra-fast MessagePack implementation with extensions for records and structured cloning

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/msgpackr@1.11.x

To install, run

npx @tessl/cli install tessl/npm-msgpackr@1.11.0

index.mddocs/

msgpackr

msgpackr is an ultra-fast MessagePack implementation for JavaScript/NodeJS that provides high-performance binary data serialization and deserialization. It offers significant speed improvements over JSON and other MessagePack implementations through optimized algorithms and optional native acceleration. The library supports structured cloning, record structure extensions for compact encoding, and streaming functionality across multiple runtime environments.

Package Information

  • Package Name: msgpackr
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install msgpackr

Core Imports

Basic imports (works in all environments):

import { pack, unpack, Packr, Unpackr } from "msgpackr";

Node.js imports (includes streaming and native acceleration):

import { pack, unpack, Packr, Unpackr, PackrStream, UnpackrStream } from "msgpackr";

For individual functionality:

import { pack, encode } from "msgpackr/pack";
import { unpack, decode, unpackMultiple } from "msgpackr/unpack";

CommonJS:

const { pack, unpack, Packr, Unpackr, PackrStream, UnpackrStream } = require("msgpackr");

Basic Usage

import { pack, unpack } from "msgpackr";

// Basic serialization
const data = { name: "Alice", age: 25, tags: ["user", "active"] };
const packed = pack(data);
const unpacked = unpack(packed);

// Using class instances for advanced features
import { Packr } from "msgpackr";
const packr = new Packr({ useRecords: true });
const serialized = packr.pack(data);
const deserialized = packr.unpack(serialized);

Architecture

msgpackr is built around several key components:

  • Core Functions: Standalone pack/unpack functions for basic MessagePack operations
  • Class-based API: Packr/Unpackr classes providing configurable instances with advanced features
  • Record Extensions: Automatic structure sharing for optimized encoding of repeated object structures
  • Streaming Interface: Transform streams for continuous data processing
  • Iterator Support: Lazy processing capabilities for large datasets
  • Native Acceleration: Optional native addon for maximum performance
  • Multi-platform Support: Browser, Node.js, Deno, and Bun compatibility

Capabilities

Core Packing and Unpacking

Basic MessagePack serialization and deserialization with high-performance implementations.

function pack(value: any, encodeOptions?: number): Buffer;
function encode(value: any, encodeOptions?: number): Buffer;
function unpack(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
function decode(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
function unpackMultiple(messagePack: Buffer | Uint8Array): any[];

type UnpackOptions = { start?: number; end?: number; lazy?: boolean; } | number;

Core Operations

Advanced Packr and Unpackr Classes

Configurable class instances providing advanced features like record structures, structured cloning, and custom extensions.

class Packr extends Unpackr {
  constructor(options?: Options);
  pack(value: any, encodeOptions?: number): Buffer;
  encode(value: any, encodeOptions?: number): Buffer;
  useBuffer(buffer: Buffer | Uint8Array): void;
  clearSharedData(): void;
}

class Unpackr {
  constructor(options?: Options);
  unpack(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
  decode(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
  unpackMultiple(messagePack: Buffer | Uint8Array): any[];
}

interface Options {
  useFloat32?: FLOAT32_OPTIONS;
  useRecords?: boolean | ((value: any) => boolean);
  structures?: {}[];
  moreTypes?: boolean;
  sequential?: boolean;
  structuredClone?: boolean;
  mapsAsObjects?: boolean;
  // ... additional options
}

Advanced Classes

Streaming Operations

Transform streams for processing continuous data flows with automatic MessagePack encoding/decoding.

class PackrStream extends Transform {
  constructor(options?: Options | StreamOptions);
}

class UnpackrStream extends Transform {
  constructor(options?: Options | StreamOptions);
}

Streaming

Iterator-based Processing

Lazy evaluation support for processing large datasets efficiently.

function packIter(
  objectIterator: Iterable | AsyncIterable, 
  options?: Options
): IterableIterator | AsyncIterableIterator;

function unpackIter(
  bufferIterator: Iterable | AsyncIterable, 
  options?: Options
): IterableIterator | AsyncIterableIterator;

// Aliases
const encodeIter: typeof packIter;
const decodeIter: typeof unpackIter;

Iterator Support

Extensions and Customization

Custom MessagePack extensions and utility functions for specialized use cases.

function addExtension(extension: Extension): void;
function clearSource(): void;
function roundFloat32(float32Number: number): number;

interface Extension {
  Class?: Function;
  type?: number;
  pack?(value: any): Buffer | Uint8Array;
  unpack?(messagePack: Buffer | Uint8Array): any;
  read?(datum: any): any;
  write?(instance: any): any;
}

Extensions

Types

enum FLOAT32_OPTIONS {
  NEVER = 0,
  ALWAYS = 1,
  DECIMAL_ROUND = 3,
  DECIMAL_FIT = 4
}

// Individual Float32 option constants (also exported separately)
const NEVER: 0;
const ALWAYS: 1;
const DECIMAL_ROUND: 3;
const DECIMAL_FIT: 4;

// Buffer mode constants
const REUSE_BUFFER_MODE: number;
const RESET_BUFFER_MODE: number;
const RESERVE_START_SPACE: number;

// Utility constants
const C1: {};
let isNativeAccelerationEnabled: boolean;

// Configuration defaults for main module
const useRecords: false;
const mapsAsObjects: true;