Global

Basic timestamp first UID generator that's good enough for most use cases but not for security purposes. There's an extremely small chance of collision, so create a map object to check for collisions if you're worried about that.

• Date.now().toString(16) is used for the timestamp, which is a base16 representation of the current timestamp in milliseconds.
• random().toString(16).substring(2) is used for the random number, which is a base16 representation of a random number between 0 and 1, with the first two characters removed.

Hold a number inside an inclusive range.

NaN comes back as NaN: neither comparison is true of it, and a range check that quietly turned it into a bound would be the wrong answer wearing a right one's clothes.

Deep clone for data. The copy shares no mutable structure with the original, the object graph survives — a value referenced twice is one object in the copy too, and a cycle terminates — and prototypes are kept, so a class instance clones into an instance of its class rather than a plain object.

The pair to deepEqual: whatever deepEqual reads as data, clone reproduces, so deepEqual(clone(x), x) holds. Handles plain and null-prototype objects, class instances, arrays including holes and subclasses, Date, RegExp with its lastIndex, Map, Set, Error with its non-enumerable message and stack, boxed primitives, ArrayBuffer, DataView and typed arrays — views over one buffer clone into views over one buffer.

Anything it does not recognise is shared by reference, not copied — a function, a DOM node, a Promise, a WeakMap, a SharedArrayBuffer, a host object. That is the difference worth having: structuredClone raises DataCloneError on all of them, so it cannot touch an options object carrying a callback or an element reference, which is most of the objects a page actually holds. Reproducing a value it cannot inspect would be the broken half-copy, so it shares instead — and never throws.

Versus the field, from bench/clone against structuredClone, rfdc 1.4.1, lodash 4.18.1, es-toolkit 1.50.0 and a JSON round-trip. rfdc is shown with its defaults, which is what rfdc() gives you; {circles: true} buys it the cycle row for 1–13%. The last four rows are semantics choices, not defects in the others; the rest are data the copy either kept or lost:

It recurses, so depth is bounded by the stack — 200 levels is nothing, 20,000 throws. A JSON round-trip is the only column that survives that, being a loop in C++, and it loses thirteen of the eighteen scored rows to be there.

The cost, on a flat eight-key object: rfdc 7.2M ops/s, this 4.0M, es-toolkit 2.4M, lodash 2.0M, ramda 1.8M, a JSON round-trip 1.7M, structuredClone 775k. rfdc leads the object shapes by 1.1–2.9×, and that lead is what its defaults buy — the six rows above where the copy comes back missing the data. If you clone plain acyclic JSON in a hot loop, use rfdc; if you want the copy to still be the value you cloned, use this.

Shape decides it, though, and this is not uniformly ahead. On an array of 10,000 numbers es-toolkit does 14k ops/s against 3k here, with structuredClone at 6k: a long flat run of primitives is what a per-key walk is worst at and a specialised array path is best at. If that is your data, this is the wrong function for it.

Where structuredClone applies — pure data, no functions or nodes — it is still the one to reach for if you are not already importing this: it ships with the platform and costs you nothing. What it is not is reliably faster. A structured clone is a serialise and a deserialise rather than a walk, so it runs 1.5–5× behind on objects and roughly 2× ahead on that flat number array, on top of dropping prototypes, symbol keys and an Error's own properties.

Finds the closest number to the set goal in an array to a given number

Removes structural duplicates from an array — deepEqual decides what a duplicate is, so property order, prototype and reference identity don't matter, contents do. The first occurrence of every distinct value is kept, in order, and the input array is left untouched.

The platform's new Set(arr) dedupes by reference identity and lodash's uniqWith(arr, isEqual) compares every pair — O(N²). Here every value folds to a 32-bit FNV-1a hash in a single walk, values collide into buckets, and deepEqual runs only within a bucket: linear in practice. The hash is free to be coarse — a shared bucket costs one comparison, while correctness comes from deepEqual alone.

Sets and Maps fold their members too, commutatively, so insertion order never reaches the hash and equal collections still land in one bucket. The bill is a walk per member on every collection: a pile of large Sets costs more to fold than a pile of small documents, and a single pair of them is a job for deepEqual rather than for this. The bucket-then-verify idea is HashCache (2013, https://stamat.wordpress.com/2013/07/03/javascript-quickly-find-very-large-objects-in-a-large-array/) with the CRC32-over-canonical-string hash replaced by a fold over the live values — no string is ever built.

Deep structural equality for data. Two values are equal when they hold the same data, regardless of reference identity, property order or prototype.

Semantics, where they differ from Node's util.isDeepStrictEqual (which browsers don't have anyway): primitives compare by SameValueZero (NaN equals NaN, 0 equals -0), prototypes are ignored (a class instance equals a plain object with the same own properties), and functions compare by reference only — functions are not data. Handles Date, RegExp, boxed primitives, Map, Set, typed arrays, ArrayBuffer/SharedArrayBuffer/DataView, symbol keys and cyclic structures. WeakMap/WeakSet contents are unobservable, so two distinct weak collections are never equal.

Versus the field, probed against fast-deep-equal 3.1.3 (/es6), dequal 2.0.3, lodash.isequal 4.5.0 and Node 25 util.isDeepStrictEqual. The last row is a semantics choice, not a defect in the others; the rest are facts:

The cost of the guarantees is small: the cycle guard only engages past recursion depth 30 (a cycle always crosses that, shallow data never pays), so on plain JSON this sits within ~15% of fast-deep-equal and dequal on nested documents and ~1.5× behind on tiny flat objects — where the remaining gap is the symbol-key pass they skip — at ~1KB min+gzip. If you compare acyclic symbol-free JSON a million times in a loop, use fast-deep-equal; if you want the answer to be right on the full range of inputs, use this.

Deep merge function that's mindful of arrays and objects. Mutates target object. shallowMerge is faster than deepMerge, so use shallowMerge when you don't need to merge nested objects or arrays.

Gets fixed number of digits after the decimal point

Generates a UUID v4

• Uses crypto.randomUUID if available
• Uses crypto.getRandomValues if available
• Uses a fallback if neither is available, which is not safe because it uses Math.random() instead of a cryptographically secure random number generator

I'm bad at crypto and bitwise operations, not my cup of tea, so I had to rely on StackOverflow for the fallback: https://stackoverflow.com/a/2117523/5437943

Access nested object properties using a path

Check if object has multiple properties

Humanize a slug, e.g. 'foo-bar' => 'Foo Bar'. Opposite of slugify. Replaces dashes and underscores with spaces and applies the chosen casing.

If provided variable is an array. Just a wrapper for Array.isArray

Check if a variable is empty

Check if an array is empty, substitute for Array.length === 0

Check if an object is empty

If provided variable is a function, substitute for typeof === 'function'

If provided variable is an object

If provided variable is a string. Just a wrapper for typeof === 'string'

A keydown built the way a browser builds one, getModifierState and all.

Maps an array of objects by a property name

Maps an array of objects by a property name to another property name

Whether a label answers what has been typed — the match a filtering list needs.

"Contains" and not "starts with": the reader looking through a list of cities for york knows New York is not spelled that way and is asking for the one word they remember. Both sides go through removeAccents and lower case, so a search typed with diacritics and one typed without both land on the same labels.

An empty search matches everything, which is what makes an unfiltered list the same code path as a filtered one.

Not slugify, further down this same file, which starts the same way and then keeps going: that one is for URLs, so it drops everything outside [\w0-9-] and leaves Београд and 北京 as empty strings. A search box that cannot find a Cyrillic city on a Serbian site is not a smaller bug than one that cannot fold an accent.

Calculates the percentage of a number in relation to another number

Pick properties from an object or elements from an array

Pick elements from an array by index, returning a new array of the picked elements

Pick properties from an object, returning a new object with only the picked properties

Dispatches at an element and lets it bubble, which is where a real keydown starts.

If object property is a function

If object property is a string

Generates a random number between 0 and 1, inclusive of 0 but not inclusive of 1.

• Uses crypto.getRandomValues if available
• Uses Math.random() if crypto.getRandomValues is not available

Generates a random integer between two values, inclusive of both

Remove properties from an object or elements from an array

Remove elements from an array by index. Indexes may be passed in any order and are deduplicated.

Remove properties from an object

A string flattened to plain Latin: the accents taken off, the letters that are two letters wearing one glyph spelled out, and the stroked letters given their plain form. Case is preserved — .toLowerCase() afterwards if a comparison needs it.

Two mechanisms, because Unicode offers no single one. NFKD decomposes and the combining marks are dropped, which handles é and ź and unpacks the ligatures and digraphs that have a compatibility decomposition — fi, DŽ, LJ, IJ. What is left has no separable mark to strip and is mapped by hand: without that pass removeAccents('Đorđe') returns Đorđe unchanged, and a [^\w] filter downstream then deletes the letter outright rather than plainifying it.

Only the scripts that share the Latin alphabet are touched. Cyrillic, Greek, Arabic and CJK come through whole, because mapping those to Latin is transliteration — a different job, answered per language rather than per character.

How fast a gesture is moving, out of the samples it has left behind.

Measured over a window of time rather than between the last two samples. A single-frame delta spikes on a quick flick - one large jump between two events sends whatever reads it straight to an extreme - and averaging the displacement over the last windowMs of movement is what smooths those spikes out.

Every numeric field except t is measured, so the answer wears the shape of the samples: { t, x, y } comes back as { x, y }, and { t, position } as { position }. One pass whatever the number of dimensions, because the window is the expensive part and it is the same window for all of them.

Fewer than two samples is not a speed. That comes back as zero for the keys the samples do carry, rather than as an empty object a caller would read undefined out of and multiply into NaN; an empty list carries no keys, so it comes back empty.

Pretends to be a Mac, or stops. jsdom leaves navigator.platform empty, so both ways are set here.

Shallow merges two objects together. Used to pass simple options to functions. Mutates the target object. Faster than deepMerge, so use when you don't need to merge nested objects or arrays.

Slugify a string, e.g. 'Foo Bar' => 'foo-bar'. Similar to WordPress' sanitize_title(). Will remove accents and HTML tags.

Anything outside [\w0-9-] is dropped, so a script with no Latin in it — Београд, 北京 — slugifies to the empty string. That is the job: a slug is for a URL. matchesSearch is the one for a search box, which keeps those scripts whole.

Try to convert a string to an array

Try to convert a string to a boolean

Try to convert a string to a number

Try to convert a string to an object

Try to convert a string to a primitive

Try to convert a string to a regex

Try to convert a string to a data type

Strip HTML tags from a string

Transforms a camelCase string to dash separated string

Transforms a dash separated string to camelCase

Truncate a string to a given number of words

Waits for a condition to become truthy, polling it until it does.

For an element appearing in the DOM reach for on instead — a MutationObserver reacts where polling only notices on its next tick. This is for what an observer cannot see: a third-party script defining its global, a widget flipping a flag, a value settling somewhere unwatchable.

The deadline is measured against the clock rather than counted in ticks, and the last sleep is cut short to land on it: a background tab clamps setTimeout to a second or more, and a caller who asked for two seconds means two seconds either way — including one last look at the moment they run out. A condition promise still pending when the deadline lands does not hold it open: the wait rejects on time and the late answer is discarded.