Utility to parse a string bytes to bytes and vice-versa
Various operations on Uint8Array data
Drag-and-drop Document Ordering without leaving the Editing surface
An iteration of the Node.js core streams with a series of improvements
Sniff the encoding from a HTML byte stream
URL and cookie safe UIDs
Convert bytes to a human readable string: 1337 → 1.34 kB
A minimal UTF8 implementation for number arrays.
Truncate string to given length in bytes
Detect Filetype by bytes
> Even though this module is publicly accessible, we do not recommend using it in projects outside of [Transloadit](https://transloadit.com). We won't make any guarantees about its workings and can change things at any time, we won't adhere strictly to Se
Detects if a file is binary in Node.js. Similar to Perl's -B.
Byte buffer specialized for data in chunks with special cases for dropping bytes in the front, merging bytes in to various integer types and abandoning buffer without penalty for previous chunk merges.
Sizeof of a JavaScript object in Bytes
Modern byte, encoding, converter registry, and PEM utilities for TypeScript projects.
(IEC) Utility to parse a string bytes to bytes and vice-versa
Compress JSON in URL friendly strings
TypeScript definitions for bytes
No description provided.
protobuf-style varint bytes - use msb to create integer values of varying sizes
Generate a unique character string suitible for use in files and URLs.
Bytes utility functions for ethers.
Left pad a string with zeros or a specified string. Fastest implementation.
Implementation of the HTML encoding sniffer algo, with stream support
Generate csv with byte order mark for Active Admin
UUIDs that are byte-ordered lamport clocks (timestamp, worker_id). Much simpler than type-1 UUID's crappy, weirdo layout.
The ByteInterpreter is a tool to interpret bytes from and encode bytes to binary files. It can either do this piecemeal, or via a set of rigid, ordered instructions that define a data structure.
ssdeep is a program for computing context triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.
EncodeM v3.0 brings complete M language (MUMPS) subscript encoding to Ruby, supporting numbers, strings, and composite keys with perfect sort order. Build hierarchical database keys like M("users", 42, "email") that sort correctly as raw bytes. This 40-year production-tested algorithm from YottaDB/GT.M powers Epic (70% of US hospitals) and VistA. Perfect for B-tree indexes, key-value stores, and any system requiring sortable hierarchical keys. All types maintain correct ordering when compared as byte strings - no decoding needed.
When you have a project in which you are not using Mongoid::Timestamps and you want to mock an object's creation time, you have to do some cumbersome operations in order to get those first 4 bytes of the ObjectId to represent the seconds since the Unix epoch that you want for that object. Particularly, if you want to have two objects with the same creation time, it would not suffice to generate the IDs via the BSON::ObjectId.from_time method, since it would yield the same ID for both objects, and you probably do not want them to be seen as the same object. This gem solves this little annoying issue by generating a unique ID for the given timestamp by using the other 8 bytes in ObjectId to generate the needed additional entropy.
A ruby implementation of the canonical serialization for the Libra network. Canonical serialization guarantees byte consistency when serializing an in-memory data structure. It is useful for situations where two parties want to efficiently compare data structures they independently maintain. It happens in consensus where independent validators need to agree on the state they independently compute. A cryptographic hash of the serialized data structure is what ultimately gets compared. In order for this to work, the serialization of the same data structures must be identical when computed by independent validators potentially running different implementations of the same spec in different languages.