@tsparticles/engine 3.0.0-alpha.0

package/types/Options/Interfaces/Particles/Collisions/ICollisionsAbsorb.d.ts

@@ -0,0 +1,3 @@
+export interface ICollisionsAbsorb {
+    speed: number;
+}

package/types/Options/Interfaces/Particles/Collisions/ICollisionsOverlap.d.ts

@@ -0,0 +1,4 @@
+export interface ICollisionsOverlap {
+    enable: boolean;
+    retries: number;
+}

package/types/Options/Interfaces/Particles/IParticlesOptions.d.ts

@@ -0,0 +1,32 @@
+import type { IAnimatableColor } from "../IAnimatableColor";
+import type { ICollisions } from "./Collisions/ICollisions";
+import type { IInteractivity } from "../Interactivity/IInteractivity";
+import type { IMove } from "./Move/IMove";
+import type { IOpacity } from "./Opacity/IOpacity";
+import type { IParticlesBounce } from "./Bounce/IParticlesBounce";
+import type { IParticlesNumber } from "./Number/IParticlesNumber";
+import type { IShadow } from "./IShadow";
+import type { IShape } from "./Shape/IShape";
+import type { ISize } from "./Size/ISize";
+import type { IStroke } from "./IStroke";
+import type { IZIndex } from "./ZIndex/IZIndex";
+import type { ParticlesGroups } from "../../../Types/ParticlesGroups";
+import type { RecursivePartial } from "../../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../../Types/SingleOrMultiple";
+export interface IParticlesOptions {
+    [name: string]: unknown;
+    bounce: IParticlesBounce;
+    collisions: ICollisions;
+    color: IAnimatableColor;
+    groups: ParticlesGroups;
+    interactivity?: RecursivePartial<IInteractivity>;
+    move: IMove;
+    number: IParticlesNumber;
+    opacity: IOpacity;
+    reduceDuplicates: boolean;
+    shadow: IShadow;
+    shape: IShape;
+    size: ISize;
+    stroke: SingleOrMultiple<IStroke>;
+    zIndex: IZIndex;
+}

package/types/Options/Interfaces/Particles/IShadow.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates } from "../../../Core/Interfaces/ICoordinates";
+import type { IOptionsColor } from "../IOptionsColor";
+export interface IShadow {
+    blur: number;
+    color: string | IOptionsColor;
+    enable: boolean;
+    offset: ICoordinates;
+}

package/types/Options/Interfaces/Particles/IStroke.d.ts

@@ -0,0 +1,8 @@
+import type { IAnimatableColor } from "../IAnimatableColor";
+import type { IColor } from "../../../Core/Interfaces/Colors";
+import type { RangeValue } from "../../../Types/RangeValue";
+export interface IStroke {
+    color?: string | IAnimatableColor | IColor;
+    opacity?: RangeValue;
+    width: RangeValue;
+}

package/types/Options/Interfaces/Particles/Move/IMove.d.ts

@@ -0,0 +1,38 @@
+import type { MoveDirection, MoveDirectionAlt } from "../../../../Enums/Directions/MoveDirection";
+import type { OutMode, OutModeAlt } from "../../../../Enums/Modes/OutMode";
+import type { IDistance } from "../../../../Core/Interfaces/IDistance";
+import type { IMoveAngle } from "./IMoveAngle";
+import type { IMoveAttract } from "./IMoveAttract";
+import type { IMoveCenter } from "./IMoveCenter";
+import type { IMoveGravity } from "./IMoveGravity";
+import type { IMovePath } from "./Path/IMovePath";
+import type { IMoveTrail } from "./IMoveTrail";
+import type { IOutModes } from "./IOutModes";
+import type { ISpin } from "./ISpin";
+import type { RangeValue } from "../../../../Types/RangeValue";
+export interface IMove {
+    angle: number | IMoveAngle;
+    attract: IMoveAttract;
+    bounce: boolean;
+    center: IMoveCenter;
+    collisions: boolean;
+    decay: RangeValue;
+    direction: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number;
+    distance: number | Partial<IDistance>;
+    drift: RangeValue;
+    enable: boolean;
+    gravity: IMoveGravity;
+    noise: IMovePath;
+    outMode: OutMode | keyof typeof OutMode | OutModeAlt;
+    outModes: IOutModes | OutMode | keyof typeof OutMode | OutModeAlt;
+    out_mode: OutMode | keyof typeof OutMode | OutModeAlt;
+    path: IMovePath;
+    random: boolean;
+    size: boolean;
+    speed: RangeValue;
+    spin: ISpin;
+    straight: boolean;
+    trail: IMoveTrail;
+    vibrate: boolean;
+    warp: boolean;
+}

package/types/Options/Interfaces/Particles/Move/IMoveAngle.d.ts

@@ -0,0 +1,5 @@
+import type { RangeValue } from "../../../../Types/RangeValue";
+export interface IMoveAngle {
+    offset: RangeValue;
+    value: RangeValue;
+}

package/types/Options/Interfaces/Particles/Move/IMoveAttract.d.ts

@@ -0,0 +1,9 @@
+import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
+import type { RangeValue } from "../../../../Types/RangeValue";
+export interface IMoveAttract {
+    distance: RangeValue;
+    enable: boolean;
+    rotate: ICoordinates;
+    rotateX: number;
+    rotateY: number;
+}

package/types/Options/Interfaces/Particles/Move/IMoveCenter.d.ts

@@ -0,0 +1,2 @@
+import type { ICenterCoordinates } from "../../../../Core/Interfaces/ICoordinates";
+export type IMoveCenter = ICenterCoordinates;

package/types/Options/Interfaces/Particles/Move/IMoveGravity.d.ts

@@ -0,0 +1,7 @@
+import type { RangeValue } from "../../../../Types/RangeValue";
+export interface IMoveGravity {
+    acceleration: RangeValue;
+    enable: boolean;
+    inverse: boolean;
+    maxSpeed: RangeValue;
+}

package/types/Options/Interfaces/Particles/Move/IMoveTrail.d.ts

@@ -0,0 +1,8 @@
+import type { IMoveTrailFill } from "./IMoveTrailFill";
+import type { IOptionsColor } from "../../IOptionsColor";
+export interface IMoveTrail {
+    enable: boolean;
+    fill: IMoveTrailFill;
+    fillColor?: string | IOptionsColor;
+    length: number;
+}

package/types/Options/Interfaces/Particles/Move/IMoveTrailFill.d.ts

@@ -0,0 +1,5 @@
+import type { IOptionsColor } from "../../IOptionsColor";
+export interface IMoveTrailFill {
+    color?: string | IOptionsColor;
+    image?: string;
+}

package/types/Options/Interfaces/Particles/Move/IOutModes.d.ts

@@ -0,0 +1,8 @@
+import type { OutMode, OutModeAlt } from "../../../../Enums/Modes/OutMode";
+export interface IOutModes {
+    bottom?: OutMode | keyof typeof OutMode | OutModeAlt;
+    default: OutMode | keyof typeof OutMode | OutModeAlt;
+    left?: OutMode | keyof typeof OutMode | OutModeAlt;
+    right?: OutMode | keyof typeof OutMode | OutModeAlt;
+    top?: OutMode | keyof typeof OutMode | OutModeAlt;
+}

package/types/Options/Interfaces/Particles/Move/ISpin.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
+import type { RangeValue } from "../../../../Types/RangeValue";
+export interface ISpin {
+    acceleration: RangeValue;
+    enable: boolean;
+    position?: ICoordinates;
+}

package/types/Options/Interfaces/Particles/Move/Path/IMovePath.d.ts

@@ -0,0 +1,9 @@
+import type { IValueWithRandom } from "../../../IValueWithRandom";
+import type { PathOptions } from "../../../../../Types/PathOptions";
+export interface IMovePath {
+    clamp: boolean;
+    delay: IValueWithRandom;
+    enable: boolean;
+    generator?: string;
+    options: PathOptions;
+}

package/types/Options/Interfaces/Particles/Number/IParticlesDensity.d.ts

@@ -0,0 +1,8 @@
+export interface IParticlesDensity {
+    area: number;
+    enable: boolean;
+    factor: number;
+    height: number;
+    value_area: number;
+    width: number;
+}

package/types/Options/Interfaces/Particles/Number/IParticlesNumber.d.ts

@@ -0,0 +1,7 @@
+import type { IParticlesDensity } from "./IParticlesDensity";
+export interface IParticlesNumber {
+    density: IParticlesDensity;
+    limit: number;
+    max: number;
+    value: number;
+}

package/types/Options/Interfaces/Particles/Opacity/IOpacity.d.ts

@@ -0,0 +1,6 @@
+import type { IOpacityAnimation } from "./IOpacityAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IOpacity extends IValueWithRandom {
+    anim: IOpacityAnimation;
+    animation: IOpacityAnimation;
+}

package/types/Options/Interfaces/Particles/Opacity/IOpacityAnimation.d.ts

@@ -0,0 +1,6 @@
+import type { DestroyType } from "../../../../Enums/Types/DestroyType";
+import type { IRangedAnimation } from "../../IAnimation";
+export interface IOpacityAnimation extends IRangedAnimation {
+    destroy: DestroyType | keyof typeof DestroyType;
+    opacity_min?: number;
+}

package/types/Options/Interfaces/Particles/Shape/ICharacterShape.d.ts

@@ -0,0 +1,8 @@
+import type { IShapeValues } from "./IShapeValues";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface ICharacterShape extends IShapeValues {
+    font: string;
+    style: string;
+    value: SingleOrMultiple<string>;
+    weight: string;
+}

package/types/Options/Interfaces/Particles/Shape/IImageShape.d.ts

@@ -0,0 +1,8 @@
+import type { IShapeValues } from "./IShapeValues";
+export interface IImageShape extends IShapeValues {
+    height: number;
+    replaceColor: boolean;
+    replace_color: boolean;
+    src: string;
+    width: number;
+}

package/types/Options/Interfaces/Particles/Shape/IPolygonShape.d.ts

@@ -0,0 +1,5 @@
+import type { IShapeValues } from "./IShapeValues";
+export interface IPolygonShape extends IShapeValues {
+    nb_sides: number;
+    sides: number;
+}

package/types/Options/Interfaces/Particles/Shape/IShape.d.ts

@@ -0,0 +1,6 @@
+import type { ShapeData } from "../../../../Types/ShapeData";
+import type { SingleOrMultiple } from "../../../../Types/SingleOrMultiple";
+export interface IShape {
+    options: ShapeData;
+    type: SingleOrMultiple<string>;
+}

package/types/Options/Interfaces/Particles/Shape/IShapeValues.d.ts

@@ -0,0 +1 @@
+export * from "../../../../Core/Interfaces/IShapeValues";

package/types/Options/Interfaces/Particles/Shape/IStarShape.d.ts

@@ -0,0 +1,6 @@
+import type { IShapeValues } from "./IShapeValues";
+export interface IStarShape extends IShapeValues {
+    inset: number;
+    nb_sides: number;
+    sides: number;
+}

package/types/Options/Interfaces/Particles/Size/ISize.d.ts

@@ -0,0 +1,6 @@
+import type { ISizeAnimation } from "./ISizeAnimation";
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface ISize extends IValueWithRandom {
+    anim: ISizeAnimation;
+    animation: ISizeAnimation;
+}

package/types/Options/Interfaces/Particles/Size/ISizeAnimation.d.ts

@@ -0,0 +1,6 @@
+import type { DestroyType } from "../../../../Enums/Types/DestroyType";
+import type { IRangedAnimation } from "../../IAnimation";
+export interface ISizeAnimation extends IRangedAnimation {
+    destroy: DestroyType | keyof typeof DestroyType;
+    size_min?: number;
+}

package/types/Options/Interfaces/Particles/ZIndex/IZIndex.d.ts

@@ -0,0 +1,6 @@
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IZIndex extends IValueWithRandom {
+    opacityRate: number;
+    sizeRate: number;
+    velocityRate: number;
+}

package/types/Options/Interfaces/Theme/ITheme.d.ts

@@ -0,0 +1,7 @@
+import type { ISourceOptions } from "../../../Types/ISourceOptions";
+import type { IThemeDefault } from "./IThemeDefault";
+export interface ITheme {
+    default: IThemeDefault;
+    name: string;
+    options?: ISourceOptions;
+}

package/types/Options/Interfaces/Theme/IThemeDefault.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeMode } from "../../../Enums/Modes/ThemeMode";
+export interface IThemeDefault {
+    auto: boolean;
+    mode: ThemeMode | keyof typeof ThemeMode;
+    value: boolean;
+}

package/types/Types/CustomEventArgs.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from "../Core/Container";
+export type CustomEventArgs = {
+    container: Container;
+    data?: unknown;
+};

package/types/Types/CustomEventListener.d.ts

@@ -0,0 +1,2 @@
+import type { CustomEventArgs } from "./CustomEventArgs";
+export type CustomEventListener = (args: CustomEventArgs) => void;

package/types/Types/ISourceOptions.d.ts

@@ -0,0 +1,3 @@
+import type { IOptions } from "../Options/Interfaces/IOptions";
+import type { RecursivePartial } from "./RecursivePartial";
+export type ISourceOptions = RecursivePartial<IOptions>;

package/types/Types/ParticlesGroups.d.ts

@@ -0,0 +1,4 @@
+import type { IParticlesOptions } from "../Options/Interfaces/Particles/IParticlesOptions";
+export type ParticlesGroups = {
+    [name: string]: IParticlesOptions;
+};

package/types/Types/PathOptions.d.ts

@@ -0,0 +1,3 @@
+export type PathOptions = {
+    [key: string]: unknown;
+};

package/types/Types/RangeValue.d.ts

@@ -0,0 +1,2 @@
+import type { IRangeValue } from "../Core/Interfaces/IRangeValue";
+export type RangeValue = number | IRangeValue;

package/types/Types/RecursivePartial.d.ts

@@ -0,0 +1,3 @@
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
+};

package/types/Types/ShapeData.d.ts

@@ -0,0 +1,5 @@
+import type { IShapeValues } from "../Core/Interfaces/IShapeValues";
+import type { SingleOrMultiple } from "./SingleOrMultiple";
+export type ShapeData = {
+    [type: string]: SingleOrMultiple<IShapeValues>;
+};

package/types/Types/ShapeDrawerFunctions.d.ts

@@ -0,0 +1,10 @@
+import type { Container } from "../Core/Container";
+import type { IDelta } from "../Core/Interfaces/IDelta";
+import type { Particle } from "../Core/Particle";
+export type ShapeDrawerDrawFunction = (context: CanvasRenderingContext2D, particle: Particle, radius: number, opacity: number, delta: IDelta, pixelRatio: number) => void;
+export type ShapeDrawerInitFunction = (container: Container) => Promise<void>;
+export type ShapeDrawerParticleInitFunction = (container: Container, particle: Particle) => void;
+export type ShapeDrawerAfterEffectFunction = (context: CanvasRenderingContext2D, particle: Particle, radius: number, opacity: number, delta: IDelta, pixelRatio: number) => void;
+export type ShapeDrawerDestroyFunction = (container: Container) => void;
+export type ShapeDrawerSidesCountFunction = (particle: Particle) => number;
+export type ShapeDrawerLoadFunction = (particle: Particle) => void;

package/types/Types/SingleOrMultiple.d.ts

@@ -0,0 +1 @@
+export type SingleOrMultiple<T> = T | T[];

package/types/Utils/CanvasUtils.d.ts

@@ -0,0 +1,23 @@
+import { AlterType } from "../Enums/Types/AlterType";
+import type { Container } from "../Core/Container";
+import type { IContainerPlugin } from "../Core/Interfaces/IContainerPlugin";
+import type { ICoordinates } from "../Core/Interfaces/ICoordinates";
+import type { IDelta } from "../Core/Interfaces/IDelta";
+import type { IDimension } from "../Core/Interfaces/IDimension";
+import type { IDrawParticleParams } from "../Core/Interfaces/IDrawParticleParams";
+import type { IHsl } from "../Core/Interfaces/Colors";
+import type { ITrailFillData } from "../Core/Interfaces/ITrailFillData";
+import type { Options } from "../Options/Classes/Options";
+import type { Particle } from "../Core/Particle";
+export declare function getContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D;
+export declare function clearCanvas(context: CanvasRenderingContext2D, size: IDimension, options: Options, trailFill?: ITrailFillData, coverColorStyle?: string): void;
+export declare function paintCanvas(context: CanvasRenderingContext2D, size: IDimension, options: Options, coverColorStyle?: string): void;
+export declare function drawLine(context: CanvasRenderingContext2D, begin: ICoordinates, end: ICoordinates): void;
+export declare function drawTriangle(context: CanvasRenderingContext2D, p1: ICoordinates, p2: ICoordinates, p3: ICoordinates): void;
+export declare function clear(context: CanvasRenderingContext2D, dimension: IDimension): void;
+export declare function drawParticle(data: IDrawParticleParams): void;
+export declare function drawShape(container: Container, context: CanvasRenderingContext2D, particle: Particle, radius: number, opacity: number, delta: IDelta): void;
+export declare function drawShapeAfterEffect(container: Container, context: CanvasRenderingContext2D, particle: Particle, radius: number, opacity: number, delta: IDelta): void;
+export declare function drawPlugin(context: CanvasRenderingContext2D, plugin: IContainerPlugin, delta: IDelta): void;
+export declare function drawParticlePlugin(context: CanvasRenderingContext2D, plugin: IContainerPlugin, particle: Particle, delta: IDelta): void;
+export declare function alterHsl(color: IHsl, type: AlterType, value: number): IHsl;

package/types/Utils/ColorUtils.d.ts

@@ -0,0 +1,24 @@
+import type { IColor, IHsl, IHsla, IRangeColor, IRgb, IRgba } from "../Core/Interfaces/Colors";
+import type { HslAnimation } from "../Options/Classes/HslAnimation";
+import type { IColorManager } from "../Core/Interfaces/IColorManager";
+import type { IOptionsColor } from "../Options/Interfaces/IOptionsColor";
+import type { IParticle } from "../Core/Interfaces/IParticle";
+import type { IParticleHslAnimation } from "../Core/Interfaces/IParticleHslAnimation";
+export declare function addColorManager(manager: IColorManager): void;
+export declare function rangeColorToRgb(input?: string | IRangeColor, index?: number, useIndex?: boolean): IRgb | undefined;
+export declare function colorToRgb(input?: string | IColor, index?: number, useIndex?: boolean): IRgb | undefined;
+export declare function colorToHsl(color: string | IColor | undefined, index?: number, useIndex?: boolean): IHsl | undefined;
+export declare function rangeColorToHsl(color: string | IRangeColor | undefined, index?: number, useIndex?: boolean): IHsl | undefined;
+export declare function rgbToHsl(color: IRgb): IHsl;
+export declare function stringToAlpha(input: string): number | undefined;
+export declare function stringToRgb(input: string): IRgb | undefined;
+export declare function hslToRgb(hsl: IHsl): IRgb;
+export declare function hslaToRgba(hsla: IHsla): IRgba;
+export declare function getRandomRgbColor(min?: number): IRgb;
+export declare function getStyleFromRgb(color: IRgb, opacity?: number): string;
+export declare function getStyleFromHsl(color: IHsl, opacity?: number): string;
+export declare function colorMix(color1: IRgb | IHsl, color2: IRgb | IHsl, size1: number, size2: number): IRgb;
+export declare function getLinkColor(p1: IParticle, p2?: IParticle, linkColor?: string | IRgb): IRgb | undefined;
+export declare function getLinkRandomColor(optColor: string | IOptionsColor, blink: boolean, consent: boolean): IRgb | string | undefined;
+export declare function getHslFromAnimation(animation?: IParticleHslAnimation): IHsl | undefined;
+export declare function getHslAnimationFromHsl(hsl: IHsl, animationOptions: HslAnimation | undefined, reduceFactor: number): IParticleHslAnimation;

package/types/Utils/EventDispatcher.d.ts

@@ -0,0 +1,11 @@
+import type { CustomEventArgs } from "../Types/CustomEventArgs";
+import type { CustomEventListener } from "../Types/CustomEventListener";
+export declare class EventDispatcher {
+    private _listeners;
+    constructor();
+    addEventListener(type: string, listener: CustomEventListener): void;
+    dispatchEvent(type: string, args: CustomEventArgs): void;
+    hasEventListener(type: string): boolean;
+    removeAllEventListeners(type?: string): void;
+    removeEventListener(type: string, listener: CustomEventListener): void;
+}

package/types/Utils/HslColorManager.d.ts

@@ -0,0 +1,10 @@
+import type { IColor, IRangeColor, IRgb, IRgba } from "../Core/Interfaces/Colors";
+import type { IColorManager } from "../Core/Interfaces/IColorManager";
+export declare class HslColorManager implements IColorManager {
+    readonly key: string;
+    readonly stringPrefix: string;
+    constructor();
+    handleColor(color: IColor): IRgb | undefined;
+    handleRangeColor(color: IRangeColor): IRgb | undefined;
+    parseString(input: string): IRgba | undefined;
+}

package/types/Utils/NumberUtils.d.ts

@@ -0,0 +1,37 @@
+import type { EasingType, EasingTypeAlt } from "../Enums/Types/EasingType";
+import type { IPositionFromSizeParams, IRangedPositionFromSizeParams } from "../Core/Interfaces/IPositionFromSizeParams";
+import type { ICoordinates } from "../Core/Interfaces/ICoordinates";
+import type { IValueWithRandom } from "../Options/Interfaces/IValueWithRandom";
+import { MoveDirection } from "../Enums/Directions/MoveDirection";
+import type { MoveDirectionAlt } from "../Enums/Directions/MoveDirection";
+import type { RangeValue } from "../Types/RangeValue";
+import { Vector } from "../Core/Utils/Vector";
+type EasingFunction = (value: number) => number;
+export declare function addEasing(name: EasingType | EasingTypeAlt, easing: EasingFunction): void;
+export declare function getEasing(name: EasingType | EasingTypeAlt): EasingFunction;
+export declare function setRandom(rnd?: () => number): void;
+export declare function getRandom(): number;
+export declare function clamp(num: number, min: number, max: number): number;
+export declare function mix(comp1: number, comp2: number, weight1: number, weight2: number): number;
+export declare function randomInRange(r: RangeValue): number;
+export declare function getRangeValue(value: RangeValue): number;
+export declare function getRangeMin(value: RangeValue): number;
+export declare function getRangeMax(value: RangeValue): number;
+export declare function setRangeValue(source: RangeValue, value?: number): RangeValue;
+export declare function getValue(options: IValueWithRandom): number;
+export declare function getDistances(pointA: ICoordinates, pointB: ICoordinates): {
+    distance: number;
+    dx: number;
+    dy: number;
+};
+export declare function getDistance(pointA: ICoordinates, pointB: ICoordinates): number;
+export declare function getParticleDirectionAngle(direction: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number, position: ICoordinates, center: ICoordinates): number;
+export declare function getParticleBaseVelocity(direction: number): Vector;
+export declare function collisionVelocity(v1: Vector, v2: Vector, m1: number, m2: number): Vector;
+export declare function calcPositionFromSize(data: IPositionFromSizeParams): ICoordinates | undefined;
+export declare function calcPositionOrRandomFromSize(data: IPositionFromSizeParams): ICoordinates;
+export declare function calcPositionOrRandomFromSizeRanged(data: IRangedPositionFromSizeParams): ICoordinates;
+export declare function calcExactPositionOrRandomFromSize(data: IPositionFromSizeParams): ICoordinates;
+export declare function calcExactPositionOrRandomFromSizeRanged(data: IRangedPositionFromSizeParams): ICoordinates;
+export declare function parseAlpha(input?: string): number;
+export {};

package/types/Utils/OptionsUtils.d.ts

@@ -0,0 +1,8 @@
+import type { Container } from "../Core/Container";
+import type { Engine } from "../engine";
+import type { IOptionLoader } from "../Options/Interfaces/IOptionLoader";
+import type { IParticlesOptions } from "../Options/Interfaces/Particles/IParticlesOptions";
+import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
+import type { RecursivePartial } from "../Types/RecursivePartial";
+export declare function loadOptions<T>(options: IOptionLoader<T>, ...sourceOptionsArr: RecursivePartial<T | undefined>[]): void;
+export declare function loadParticlesOptions(engine: Engine, container: Container, ...sourceOptionsArr: RecursivePartial<IParticlesOptions | undefined>[]): ParticlesOptions;

package/types/Utils/RgbColorManager.d.ts

@@ -0,0 +1,10 @@
+import type { IColor, IRangeColor, IRgb, IRgba } from "../Core/Interfaces/Colors";
+import type { IColorManager } from "../Core/Interfaces/IColorManager";
+export declare class RgbColorManager implements IColorManager {
+    readonly key: string;
+    readonly stringPrefix: string;
+    constructor();
+    handleColor(color: IColor): IRgb | undefined;
+    handleRangeColor(color: IRangeColor): IRgb | undefined;
+    parseString(input: string): IRgba | undefined;
+}

package/types/Utils/Utils.d.ts

@@ -0,0 +1,36 @@
+import type { DivEvent } from "../Options/Classes/Interactivity/Events/DivEvent";
+import type { DivMode } from "../Enums/Modes/DivMode";
+import type { IBounds } from "../Core/Interfaces/IBounds";
+import type { ICircleBouncer } from "../Core/Interfaces/ICircleBouncer";
+import type { ICoordinates } from "../Core/Interfaces/ICoordinates";
+import type { IDimension } from "../Core/Interfaces/IDimension";
+import type { IModeDiv } from "../Options/Interfaces/Interactivity/Modes/IModeDiv";
+import type { IParticle } from "../Core/Interfaces/IParticle";
+import type { IParticleNumericValueAnimation } from "../Core/Interfaces/IParticleValueAnimation";
+import { OutModeDirection } from "../Enums/Directions/OutModeDirection";
+import type { RangedAnimationValueWithRandom } from "../Options/Classes/ValueWithRandom";
+import type { SingleOrMultiple } from "../Types/SingleOrMultiple";
+export declare function isSsr(): boolean;
+export declare function hasMatchMedia(): boolean;
+export declare function safeMatchMedia(query: string): MediaQueryList | undefined;
+export declare function animate(): (callback: FrameRequestCallback) => number;
+export declare function cancelAnimation(): (handle: number) => void;
+export declare function isInArray<T>(value: T, array: SingleOrMultiple<T>): boolean;
+export declare function loadFont(font?: string, weight?: string): Promise<void>;
+export declare function arrayRandomIndex<T>(array: T[]): number;
+export declare function itemFromArray<T>(array: T[], index?: number, useIndex?: boolean): T;
+export declare function isPointInside(point: ICoordinates, size: IDimension, offset: ICoordinates, radius?: number, direction?: OutModeDirection): boolean;
+export declare function areBoundsInside(bounds: IBounds, size: IDimension, offset: ICoordinates, direction?: OutModeDirection): boolean;
+export declare function calculateBounds(point: ICoordinates, radius: number): IBounds;
+export declare function deepExtend(destination: unknown, ...sources: unknown[]): unknown;
+export declare function isDivModeEnabled(mode: DivMode, divs: SingleOrMultiple<DivEvent>): boolean;
+export declare function divModeExecute(mode: DivMode, divs: SingleOrMultiple<DivEvent>, callback: (id: string, div: DivEvent) => void): void;
+export declare function singleDivModeExecute(div: DivEvent, callback: (selector: string, div: DivEvent) => void): void;
+export declare function divMode<T extends IModeDiv>(divs?: SingleOrMultiple<T>, element?: HTMLElement): T | undefined;
+export declare function circleBounceDataFromParticle(p: IParticle): ICircleBouncer;
+export declare function circleBounce(p1: ICircleBouncer, p2: ICircleBouncer): void;
+export declare function rectBounce(particle: IParticle, divBounds: IBounds): void;
+export declare function executeOnSingleOrMultiple<T, U = void>(obj: SingleOrMultiple<T>, callback: (obj: T, index: number) => U): SingleOrMultiple<U>;
+export declare function itemFromSingleOrMultiple<T>(obj: SingleOrMultiple<T>, index?: number, useIndex?: boolean): T;
+export declare function findItemFromSingleOrMultiple<T>(obj: SingleOrMultiple<T>, callback: (obj: T, index: number) => boolean): T | undefined;
+export declare function initParticleNumericAnimationValue(options: RangedAnimationValueWithRandom, pxRatio: number): IParticleNumericValueAnimation;