Generate hashes from javascript objects in node and the browser.
Resolve a URI relative to an optional base URI
Stable JS value hash.
Implementation of JSON Web Signatures
JWA implementation (supports all JWS algorithms)
A MurmurHash2 implementation
An incremental implementation of MurmurHash3
abstract base class for hash-streams
Stable JS value hash.
A pure JS implementation SHA256.
Easing functions for smooth animation.
Pack RGBA color channels into uint32 and back
SHA256 wrapper for browsers that prefers `window.crypto.subtle` but will fall back to a pure JS implementation in @aws-crypto/sha256-js to provide a consistent interface for SHA256.
Hashing made simple. Get the hash of a buffer/string/stream/file.
create hashes for browserify
Generates a hash for an installed npm package, useful for salting caches
Newline character converter
Create a base32 hash
A collection of utilities for better-auth
Lightning fast normal and incremental md5 for javascript
Node.js object hash library with properties/arrays sorting to provide constant hashes
oidc-token-hash validates (and generates) ID Token `_hash` claims such as `at_hash` or `c_hash`
A simple MD5 hash function for JavaScript supports UTF-8 encoding.
TypeScript definitions for object-hash
Cross-platform hash algorithm.
Create cross-platform hashes of text files.
Specification of Normalized Hash data structure main goal is to make data produced by parsers easy to use by software that does not know about internal data structure, i.e. data driven and schema-less. Data structures should be built in such a way as to make data self-documenting, easy adaptable and 'software-friendly'. Gem contains RSpec tests for testing Hash data structure for compliance with the requirements. See README.md and NormalizedHash.md files in gem's root directory.
Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL.
Normalize deeply nested hash based on a schema
converts multiple formats of csv data into hashes with a normalized format
Provides normalization and hashing utilities for Yara rule comparisons.
A hash that can inherit entries from other normal hashes or other inheritance hashes.
A simple mixin layer for enhancing hashes retrieved from MongoDB. It eschews the normal 'mapping' compulsion of mongo libraries.
Ozymandias (or "Ozy" for short) allows you to use a Hash normally, but to have its changes persisted to Redis. It's very simple and very awesome.
A persistant, file based hash
Morphix provides a clear, expressive DSL for transforming data structures in Ruby. Perfect for API response normalization, JSON reshaping, and ETL pipelines.
FancyOpenStruct is a subclass of OpenStruct, and is a variant of RecursiveOpenStruct. This allows you to convert nested hashes into a structure where keys and values can be navigated and modified via dot-syntax, like: foo.bar = :something. This particular gem also adds support for Hash methods (such as length or merge), and also allows you to access and modify the data structure the same way that you would handle a normal Hash.
Similar in behavior to Object#presence defined in ActiveSupport, Significance is a state which determines not just the blank-ness of an object but whether or not the non-blank object has any real-world value. The utility of this gem can best be demonstrated when considering the merging of two hashes. Under normal circumstances the mere existence of an equivalent key in the second hash results in its overriding the corresponding value in the original hash. Using Hash#significant_merge, however, the second hash will retain only key-value pairs whose values are "significant," even applying the significance filter recursively into child hashes or arrays.