JSPM

This package includes a set of useful array methods that facilitates working with arrays, specifically the arrays that contain objects or arrays even falsy values (such as: 0, null, false, NaN...). This package is es5 supported.

Hook for intersection observer

Superfast and small intersection supporting primitives and objects. Up to 3x faster than other libraries. In the age of big data, you need it.

An implementation of the Watertight Ray/Triangle Intersection algorithm

React library for observing and loading blocks of items in lists.

Script for lazyloading assets using Intersection Observer API

LISN.js browser bundles.

Monitor the scroll percentage of a component inside the viewport, using the IntersectionObserver API.

fast line intersection

Simple Intersection Observer hook for React

Custom hook designed to detect if an element is visible within the viewport.

A javascript library for working with objects

Fast and robust triangle-triangle intersection test with high precision for cross and coplanar triangles based on the algorithm by Devillers & Guigue.

An extension of the javascript Set object which contains useful Set operation methods

Monitor if a component is inside the viewport, using IntersectionObserver API

Geometry intersection and bounding volume helpers for PEX.

A lightweight and simple React hook for detecting if an element is in the viewport using the Intersection Observer API. Perfect for lazy loading, infinite scrolling, animations, and more!

Intersect sorted lists using merge intersection with galloping lookahead

Plain vanilla JS IntersectionObserver utility, to be used as a mixin

A utility that takes 1 or more sorted arrays and emits a node stream event whenever an intersection is found

Returns the symmetric difference (exclusive-or) of an array of elements (elements that are present in all given arrays and not in their intersections).

Simply handle user gestures and actions. Includes widgets.

A group of functions for working with Maps.

A collection of observers for Svelte

LISN.js for React.

An easy-to-use React hook that tells you whether a component/element is visible on the viewport currently, and if yes, how much of it is visible.

A Bounding Volume Hierarchy data structure, for fast ray-mesh intersection

A visibility based trigger for loading more data.

Determines whether any of the segments of 2 given linestrings intersect

Gives values present in both arrays.

A group of functions for working with Maps {web}.

Performant & ergonomic 2D geometry in typescript

A collection of methods for working with Objects {web}.

A collection of methods for working with Objects.

Frequently used tools for React

ILists is a pair of key iterable list and value iterable list, with unique keys.

Alpine JS magic helper that determines when elements overlap or intersect each other, perfect for menus, tooltips, modals, and collision detection 🥞

Tailwind CSS with Intersection Observer & Load variants

React Hook to call an action if an intersected element was reached

An Alpine.js plugin to easily add CSS classes to an element when it enters the viewport.

ILists is a pair of key iterable list and value iterable list, with unique keys {web}.

A sorted array is a collection of values, arranged in an order {web}.

A small wrapper around turf-intersect to safely clip one geojson polygon to another

A sorted array is a collection of values, arranged in an order.

A collection of functions for operating upon Entries {web}.

An array is a collection of values, stored contiguously {web}.

A collection of functions for operating upon Entries.

IntersectionTrigger utilizes the most modern web technology to trigger anything by intersection. Including scroll-based animations.

A pack of functions for working with Sets {web}.

Find the intersection of two glob patterns

A helper to work with rectangular regions in the DOM

Node.js utility functions to handle objects

A dependency free utility to set and remove animation classes on elements as they become visible in the viewport, using the Intersection Observer API

A set of helpers in TS/JS, compatible with tree-shaking, for array.

Gives values present in both arrays.

A collection of functions for operating upon Lists.

Bounding interval hierarchy and bounding volume hierarchy library for nodejs

IntersectionObserver MenuSpy

Node utility librairies

A simple and fast API to manage viewport and DOM elements intersections as you scroll

Vue JS lazy image loading

compute the intersection between two intervals

An iterable is a sequence of values {web}.

Creates an array of unique values that are included in all given arrays.

A fork from pelias/polygon-lookup with updated dependencies

A collection of helpers for detecting intersections in 2D and 3D

Lazy load component with react && react-router.

A collection of functions for operating upon Lists {web}.

a plugin for vue exposure, used by intersection observer API

Small wrapper for IntersectionObserver, to use it more modular way.

Styled components syntax for creating raw html in javascript.

React hook for using intersetion observers.

Dasboard for React

Javascript Object Extensions

Counts occurrences of values.

React Hook for Tracking Section Visibility in the Viewport

A React component that supports infinite scroll using Intersection Observer API

Apply boolean polygon clipping operations (union, intersection, difference, xor) to Polygons & MultiPolygons in your GeoJSON files.

Creates an array of unique values, in order, from all given arrays.

test if a ray intersects an aabb in 2d/3d space

Apply boolean polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

ReactJS component that applies CSS styles as it approaches the top of the viewport.

A JavaScript port of the polyclip library

Returns evenly spaced values within given interval.

Render on intersection

A library for slideup animation using directive with Angular

Framework agnostic library to detect viewable impressions

detect if a 2D triangle and circle collide

A basic library for some utility functions

This is a React component that loads an image source, only after it is partially or fully visible in the viewport

Simple Javascript IntersectionObserver implementation for Ember applications.

RegexSolver allows you to manipulate regular expressions as sets, enabling operations such as intersection, union, and subtraction.

An easier way to observe the intersections with the viewport


Creates an array of unique values that are included in all given arrays.

Circle Intersection Regions

Boolean operations on polygons

Greiner-Hormann clipping algorithm; Typescript port.

React lazy loading component using vanilla-lazyload library. Speedy, lightweight and easy to use.

Counts occurrences of values.

Monitor if a component is inside the viewport, using IntersectionObserver API

Apply boolean Polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

Create an iterator which returns the intersection of two or more iterators.

Frequently used tools for React

Creates an array of unique values that are included in all given arrays.

Provides a way with extra configuration options to execute a handler when a given element is on view.

Gives values present in both arrays.

BVH

Returns evenly spaced values within given interval.

TailwindCSS Zen intersection animation plugin

Test if two triangles in the plane intersect

Helpers for Set objects.

Scalable distinct value counting system

Zero-dependency TypeScript runtime type validation with full type inference

Get callback when a DOM element enters or leaves the viewport.

Scroll position-related navigation state management

Flattens nested array to given depth.

An esay-to-use wrapper class over intersection observer API.

A Bounding Volume Hierarchy data structure, for fast ray-mesh intersection

Javascript library for 2d geometry

The package is a "sentinel" that trigger a function when is visible.

A wrapper for @loadable/component that uses IntersectionObserver to trigger component load.

Allows Union, Difference, Xor, and Intersection operations on two polygons.

Given a graph with a graph with a non planar embedding, make changes to this graph so that it becomes planar.

Extremely fast set and map/reduce operations for Arrays and Sets plus CartesianProducts

A libraray for Isochrone, Routing & geoprocessing GeoJson Data

Implementation of range data structures using plain JavaScript arrays.

A minimalistic es6 implementation of set

Lazy Loading images and other (JS, etc.) using Intersection Observer with polyfill

Find the symmetric difference of two string arrays.

A lightweight TypeScript library providing utilities for observing intersection and resize events of DOM elements with automatic cleanup.

A React hook that tells you when an element enters or leaves the viewport.

Calculate intersection of two lines

🔢 JavaScript range validation library - Extend Number and BigInt prototypes with powerful range checking, validation, and manipulation utilities. Perfect for form validation, game development, and scientific computing.

Fast testing whether two line segments intersect

More operations on Sets: union, intersection, include, etc.

A library for working with Sets and arrays as sets.

Rearranges values in arbitrary order.

Javascript library for 2d geometry. Cloned from flattenjs

A BVH implementation to speed up raycasting against three.js meshes.

Flattens nested array to given depth.

Detect self-intersecting polygons in Javascript. An implementation of the Bentley–Ottmann sweep line algorithm for detecting crossings in a set of line segments.

Handle your array objects with ease

A utility library providing common array manipulations and React hooks.

test for the intersection of convex polytopes in 2d or 3d, computing the minimum translation vector

Gives values present in both arrays.

Javascript library for 2d geometry

Returns the vertices of multiple circle intersection

React utilities for lazy image loading

Return intersect object that have same key from a number of objects

Set Operations in Typescript

Create an iterator which returns the intersection of two or more iterators according to a hash function.

Remove self intersections, t-junctions and duplicate edges/vertices from a planar straight line graph

Detects if the inner children are visible

Rearranges values in arbitrary order.

An API (wrapper actually) for connect trough Intersection Controller game data like users and maps

calculate the intersection of a ray and a disk or plane in three dimensions

wip

React standard library

Find all intersections between two sets of line segments

Two dimensional geometry manipulation

[Deprecated] JST to perform set intersection and set subtraction operations on 2 user provided arrays

Helper making the observation of element's visibility a little more convenient. Based on the IntersectionObserver API.

Find unique common elements among given arrays

Broad coverage of sorted array operations

Set implementation with some extra utils

Automatically lazy load images inserted into the DOM

React utilities for lazy image loading

[![npm package][npm-badge]][npm] ![Module formats][module-formats]

React utilities for lazy image loading - Patched version

Returns the items two arrays do not share

Rearranges values in arbitrary order.

Apply boolean Polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

Disjoint continuous ranges

Experimental API for observing the visible box of an element.

Add additional features to a TypeScript type at runtime

Bezier curve intersection algorithm and utilities

A set of useful functions that give easier control over set manipulation

Combine user-defined type guards / type predicates as unions and intersections.

Provides functions to operate on Sets, Arrays and Array-Like JavaScript data structures

Week day picker for React

A JS/TS library that expands upon the functionality of Sets

Manipulation with date periods: intersection, splitting etc.

Extending the Set class in order to support mathematical set properties and operations.

Takes two lines and returns all intersection points

JavaScript Package for Creating an array without duplicates

Get an intersection of multiple arrays and account objects.

A scroll-to-reveal JavaScript library that unmasks your elements using the clip-path CSS property.

add intersection events to dom elements

Simple modules for functional programming, done for fun.

Rearranges values in arbitrary order.

intersections of sorted streams

This will return the array of objects that are common in a set of array of objects based on single or multiple keys

Find all intersections in a set of intervals

A set implementation for integers

a node.js port of jsclipper [JS]... which is a port of clipper [C++, C#, Delphi]

Compute the closest point between two line segments

ray aabb intersection test using the slab method

generate array of intersection points from array and geometry

Snap points to the nearest point in a GeoJSON collection of points.

Simple robust library for finding lines intersections fast.

Javascript Set operations

React <img> drop-in replacement for lazy image loading

A BVH implementation to speed up raycasting against three.js meshes.

Checks if two circles intersect.

Angular library that wraps the browser IntersectionObserver in an Angular directive

Function extensions for JavaScript's built-in Set type

Wrapper for IntersectionObserver that returns the scroll direction

calculate the intersection of a ray and a cone in three dimensions

A collection of common algorithm ulities including Binary Search

Simple intersection implement.

Modern React component for scroll-based triggers and animations with TypeScript support. A rewritten and modernized version of the original react-scroll-trigger package.

Week day picker for React

Set, but for Objects.

Perform Set Operations (Union|Intersection|Difference) on SVG Paths

intersection and difference

web component that dispatches an event whenever it comes in and goes out of viewport

A batteries include Set class built on top of ES6 sets

Adds a directive that listens for click events and scrolls to elements.

A very simple script to compute the intersection point of two great circles specified using two points. The intersection point is computed either in the Cartesian plane of its coordinates or on a Sphere.

Supply visibility classes and data to selected elements on your webpage.

A lightweight library of basic geometry shapes interactions

🧮 Common set operations (union, difference, isSubset, etc.) for any Iterable

Javascript module for in view animations using the Javascript IntersectionObserver.

**React Lazily IMG** is a React Wrapper Component to lazily load images. The goal is to use the convenient and known standard HTML tags and just have them lazily loaded.

React utilities for lazy image loading

React utilities for lazy image loading

React hook to use intersection API

This is a simple React Hooks that trigger a callback all time the element is viewed.

Scroll through a list of data quickly

LazyLoading for the New Millenium™

A tiny library for lazily loading any content in React

- Version 1.0.2 Rename directive selector rtIsElementVisible to rtIsVisibleElement - Version 1.0.3 Edit readme

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.0.2.

R.intersection exported as a module

To compute axis which some integer ranges on it

Union and Intersection operators for highland.js streams

A fork from pelias/polygon-lookup with updated dependencies

Compute intersections & unions of streams

R.intersection exported as a module

JavaScript Set prototype extensions using Metho

Angular-inspired deferred loading for React with compound triggers, prefetching, and advanced performance optimizations

Compare two sets (array of items) and get relationships between them (Disjoint | Intersecting | Subset | Superset | Equal)

Find characters in a string that also occur in another string

Utility to check if polygons overlap.

Detect self-intersecting polygons in Javascript. An implementation of the Bentley–Ottmann sweep-line algorithm with redblack tree for detecting crossings in a set of line segments.

A library of intersection algorithms covering all SVG shape types

Catching the moment when the specific part of an element is visible in the viewport

intersect a ray with a quadtree

Extend Quasar animation system