Initial commit

node_modules/embla-carousel/components/Alignment.d.ts

@@ -0,0 +1,5 @@
+export type AlignmentOptionType = 'start' | 'center' | 'end' | ((viewSize: number, snapSize: number, index: number) => number);
+export type AlignmentType = {
+    measure: (n: number, index: number) => number;
+};
+export declare function Alignment(align: AlignmentOptionType, viewSize: number): AlignmentType;

node_modules/embla-carousel/components/Animations.d.ts

@@ -0,0 +1,13 @@
+import { EngineType } from './Engine';
+import { WindowType } from './utils';
+export type AnimationsUpdateType = (engine: EngineType, timeStep: number) => void;
+export type AnimationsRenderType = (engine: EngineType, lagOffset: number) => void;
+export type AnimationsType = {
+    init: () => void;
+    destroy: () => void;
+    start: () => void;
+    stop: () => void;
+    update: () => void;
+    render: (lagOffset: number) => void;
+};
+export declare function Animations(ownerDocument: Document, ownerWindow: WindowType, update: (timeStep: number) => void, render: (lagOffset: number) => void): AnimationsType;

node_modules/embla-carousel/components/Axis.d.ts

@@ -0,0 +1,14 @@
+import { NodeRectType } from './NodeRects';
+export type AxisOptionType = 'x' | 'y';
+export type AxisDirectionOptionType = 'ltr' | 'rtl';
+type AxisEdgeType = 'top' | 'right' | 'bottom' | 'left';
+export type AxisType = {
+    scroll: AxisOptionType;
+    cross: AxisOptionType;
+    startEdge: AxisEdgeType;
+    endEdge: AxisEdgeType;
+    measureSize: (nodeRect: NodeRectType) => number;
+    direction: (n: number) => number;
+};
+export declare function Axis(axis: AxisOptionType, contentDirection: AxisDirectionOptionType): AxisType;
+export {};

node_modules/embla-carousel/components/Counter.d.ts

@@ -0,0 +1,7 @@
+export type CounterType = {
+    get: () => number;
+    set: (n: number) => CounterType;
+    add: (n: number) => CounterType;
+    clone: () => CounterType;
+};
+export declare function Counter(max: number, start: number, loop: boolean): CounterType;

node_modules/embla-carousel/components/DragHandler.d.ts

@@ -0,0 +1,21 @@
+import { EmblaCarouselType } from './EmblaCarousel';
+import { AnimationsType } from './Animations';
+import { CounterType } from './Counter';
+import { DragTrackerType, PointerEventType } from './DragTracker';
+import { EventHandlerType } from './EventHandler';
+import { AxisType } from './Axis';
+import { ScrollBodyType } from './ScrollBody';
+import { ScrollTargetType } from './ScrollTarget';
+import { ScrollToType } from './ScrollTo';
+import { Vector1DType } from './Vector1d';
+import { PercentOfViewType } from './PercentOfView';
+import { WindowType } from './utils';
+type DragHandlerCallbackType = (emblaApi: EmblaCarouselType, evt: PointerEventType) => boolean | void;
+export type DragHandlerOptionType = boolean | DragHandlerCallbackType;
+export type DragHandlerType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+    destroy: () => void;
+    pointerDown: () => boolean;
+};
+export declare function DragHandler(axis: AxisType, rootNode: HTMLElement, ownerDocument: Document, ownerWindow: WindowType, target: Vector1DType, dragTracker: DragTrackerType, location: Vector1DType, animation: AnimationsType, scrollTo: ScrollToType, scrollBody: ScrollBodyType, scrollTarget: ScrollTargetType, index: CounterType, eventHandler: EventHandlerType, percentOfView: PercentOfViewType, dragFree: boolean, dragThreshold: number, skipSnaps: boolean, baseFriction: number, watchDrag: DragHandlerOptionType): DragHandlerType;
+export {};

node_modules/embla-carousel/components/DragTracker.d.ts

@@ -0,0 +1,10 @@
+import { AxisOptionType, AxisType } from './Axis';
+import { WindowType } from './utils';
+export type PointerEventType = TouchEvent | MouseEvent;
+export type DragTrackerType = {
+    pointerDown: (evt: PointerEventType) => number;
+    pointerMove: (evt: PointerEventType) => number;
+    pointerUp: (evt: PointerEventType) => number;
+    readPoint: (evt: PointerEventType, evtAxis?: AxisOptionType) => number;
+};
+export declare function DragTracker(axis: AxisType, ownerWindow: WindowType): DragTrackerType;

node_modules/embla-carousel/components/EmblaCarousel.d.ts

@@ -0,0 +1,32 @@
+import { EngineType } from './Engine';
+import { EventHandlerType } from './EventHandler';
+import { EmblaOptionsType } from './Options';
+import { EmblaPluginsType, EmblaPluginType } from './Plugins';
+export type EmblaCarouselType = {
+    canScrollNext: () => boolean;
+    canScrollPrev: () => boolean;
+    containerNode: () => HTMLElement;
+    internalEngine: () => EngineType;
+    destroy: () => void;
+    off: EventHandlerType['off'];
+    on: EventHandlerType['on'];
+    emit: EventHandlerType['emit'];
+    plugins: () => EmblaPluginsType;
+    previousScrollSnap: () => number;
+    reInit: (options?: EmblaOptionsType, plugins?: EmblaPluginType[]) => void;
+    rootNode: () => HTMLElement;
+    scrollNext: (jump?: boolean) => void;
+    scrollPrev: (jump?: boolean) => void;
+    scrollProgress: () => number;
+    scrollSnapList: () => number[];
+    scrollTo: (index: number, jump?: boolean) => void;
+    selectedScrollSnap: () => number;
+    slideNodes: () => HTMLElement[];
+    slidesInView: () => number[];
+    slidesNotInView: () => number[];
+};
+declare function EmblaCarousel(root: HTMLElement, userOptions?: EmblaOptionsType, userPlugins?: EmblaPluginType[]): EmblaCarouselType;
+declare namespace EmblaCarousel {
+    let globalOptions: EmblaOptionsType | undefined;
+}
+export default EmblaCarousel;

node_modules/embla-carousel/components/Engine.d.ts

@@ -0,0 +1,64 @@
+import { AnimationsType } from './Animations';
+import { AxisType } from './Axis';
+import { CounterType } from './Counter';
+import { DragHandlerType } from './DragHandler';
+import { EventHandlerType } from './EventHandler';
+import { EventStoreType } from './EventStore';
+import { LimitType } from './Limit';
+import { NodeRectType } from './NodeRects';
+import { OptionsType } from './Options';
+import { PercentOfViewType } from './PercentOfView';
+import { ResizeHandlerType } from './ResizeHandler';
+import { ScrollBodyType } from './ScrollBody';
+import { ScrollBoundsType } from './ScrollBounds';
+import { ScrollLooperType } from './ScrollLooper';
+import { ScrollProgressType } from './ScrollProgress';
+import { SlideRegistryType } from './SlideRegistry';
+import { ScrollTargetType } from './ScrollTarget';
+import { ScrollToType } from './ScrollTo';
+import { SlideFocusType } from './SlideFocus';
+import { SlideLooperType } from './SlideLooper';
+import { SlidesHandlerType } from './SlidesHandler';
+import { SlidesInViewType } from './SlidesInView';
+import { SlidesToScrollType } from './SlidesToScroll';
+import { TranslateType } from './Translate';
+import { WindowType } from './utils';
+import { Vector1DType } from './Vector1d';
+export type EngineType = {
+    ownerDocument: Document;
+    ownerWindow: WindowType;
+    eventHandler: EventHandlerType;
+    axis: AxisType;
+    animation: AnimationsType;
+    scrollBounds: ScrollBoundsType;
+    scrollLooper: ScrollLooperType;
+    scrollProgress: ScrollProgressType;
+    index: CounterType;
+    indexPrevious: CounterType;
+    limit: LimitType;
+    location: Vector1DType;
+    offsetLocation: Vector1DType;
+    previousLocation: Vector1DType;
+    options: OptionsType;
+    percentOfView: PercentOfViewType;
+    scrollBody: ScrollBodyType;
+    dragHandler: DragHandlerType;
+    eventStore: EventStoreType;
+    slideLooper: SlideLooperType;
+    slidesInView: SlidesInViewType;
+    slidesToScroll: SlidesToScrollType;
+    target: Vector1DType;
+    translate: TranslateType;
+    resizeHandler: ResizeHandlerType;
+    slidesHandler: SlidesHandlerType;
+    scrollTo: ScrollToType;
+    scrollTarget: ScrollTargetType;
+    scrollSnapList: number[];
+    scrollSnaps: number[];
+    slideIndexes: number[];
+    slideFocus: SlideFocusType;
+    slideRegistry: SlideRegistryType['slideRegistry'];
+    containerRect: NodeRectType;
+    slideRects: NodeRectType[];
+};
+export declare function Engine(root: HTMLElement, container: HTMLElement, slides: HTMLElement[], ownerDocument: Document, ownerWindow: WindowType, options: OptionsType, eventHandler: EventHandlerType): EngineType;

node_modules/embla-carousel/components/EventHandler.d.ts

@@ -0,0 +1,27 @@
+import { EmblaCarouselType } from './EmblaCarousel';
+type CallbackType = (emblaApi: EmblaCarouselType, evt: EmblaEventType) => void;
+export type EmblaEventType = EmblaEventListType[keyof EmblaEventListType];
+export interface EmblaEventListType {
+    init: 'init';
+    pointerDown: 'pointerDown';
+    pointerUp: 'pointerUp';
+    slidesChanged: 'slidesChanged';
+    slidesInView: 'slidesInView';
+    scroll: 'scroll';
+    select: 'select';
+    settle: 'settle';
+    destroy: 'destroy';
+    reInit: 'reInit';
+    resize: 'resize';
+    slideFocusStart: 'slideFocusStart';
+    slideFocus: 'slideFocus';
+}
+export type EventHandlerType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+    emit: (evt: EmblaEventType) => EventHandlerType;
+    on: (evt: EmblaEventType, cb: CallbackType) => EventHandlerType;
+    off: (evt: EmblaEventType, cb: CallbackType) => EventHandlerType;
+    clear: () => void;
+};
+export declare function EventHandler(): EventHandlerType;
+export {};

node_modules/embla-carousel/components/EventStore.d.ts

@@ -0,0 +1,9 @@
+type EventNameType = keyof DocumentEventMap | keyof WindowEventMap;
+type EventHandlerType = (evt: any) => void;
+type EventOptionsType = boolean | AddEventListenerOptions | undefined;
+export type EventStoreType = {
+    add: (node: EventTarget, type: EventNameType, handler: EventHandlerType, options?: EventOptionsType) => EventStoreType;
+    clear: () => void;
+};
+export declare function EventStore(): EventStoreType;
+export {};

node_modules/embla-carousel/components/Limit.d.ts

@@ -0,0 +1,11 @@
+export type LimitType = {
+    min: number;
+    max: number;
+    length: number;
+    constrain: (n: number) => number;
+    reachedAny: (n: number) => boolean;
+    reachedMax: (n: number) => boolean;
+    reachedMin: (n: number) => boolean;
+    removeOffset: (n: number) => number;
+};
+export declare function Limit(min?: number, max?: number): LimitType;

node_modules/embla-carousel/components/NodeRects.d.ts

@@ -0,0 +1,12 @@
+export type NodeRectType = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type NodeRectsType = {
+    measure: (node: HTMLElement) => NodeRectType;
+};
+export declare function NodeRects(): NodeRectsType;

node_modules/embla-carousel/components/Options.d.ts

@@ -0,0 +1,40 @@
+import { AlignmentOptionType } from './Alignment';
+import { AxisDirectionOptionType, AxisOptionType } from './Axis';
+import { SlidesToScrollOptionType } from './SlidesToScroll';
+import { ScrollContainOptionType } from './ScrollContain';
+import { DragHandlerOptionType } from './DragHandler';
+import { ResizeHandlerOptionType } from './ResizeHandler';
+import { SlidesHandlerOptionType } from './SlidesHandler';
+import { SlidesInViewOptionsType } from './SlidesInView';
+import { FocusHandlerOptionType } from './SlideFocus';
+export type LooseOptionsType = {
+    [key: string]: unknown;
+};
+export type CreateOptionsType<Type extends LooseOptionsType> = Type & {
+    active: boolean;
+    breakpoints: {
+        [key: string]: Omit<Partial<CreateOptionsType<Type>>, 'breakpoints'>;
+    };
+};
+export type OptionsType = CreateOptionsType<{
+    align: AlignmentOptionType;
+    axis: AxisOptionType;
+    container: string | HTMLElement | null;
+    slides: string | HTMLElement[] | NodeListOf<HTMLElement> | null;
+    containScroll: ScrollContainOptionType;
+    direction: AxisDirectionOptionType;
+    slidesToScroll: SlidesToScrollOptionType;
+    dragFree: boolean;
+    dragThreshold: number;
+    inViewThreshold: SlidesInViewOptionsType;
+    loop: boolean;
+    skipSnaps: boolean;
+    duration: number;
+    startIndex: number;
+    watchDrag: DragHandlerOptionType;
+    watchResize: ResizeHandlerOptionType;
+    watchSlides: SlidesHandlerOptionType;
+    watchFocus: FocusHandlerOptionType;
+}>;
+export declare const defaultOptions: OptionsType;
+export type EmblaOptionsType = Partial<OptionsType>;

node_modules/embla-carousel/components/OptionsHandler.d.ts

@@ -0,0 +1,10 @@
+import { LooseOptionsType, CreateOptionsType } from './Options';
+import { WindowType } from './utils';
+type OptionsType = Partial<CreateOptionsType<LooseOptionsType>>;
+export type OptionsHandlerType = {
+    mergeOptions: <TypeA extends OptionsType, TypeB extends OptionsType>(optionsA: TypeA, optionsB?: TypeB) => TypeA;
+    optionsAtMedia: <Type extends OptionsType>(options: Type) => Type;
+    optionsMediaQueries: (optionsList: OptionsType[]) => MediaQueryList[];
+};
+export declare function OptionsHandler(ownerWindow: WindowType): OptionsHandlerType;
+export {};

node_modules/embla-carousel/components/PercentOfView.d.ts

@@ -0,0 +1,4 @@
+export type PercentOfViewType = {
+    measure: (n: number) => number;
+};
+export declare function PercentOfView(viewSize: number): PercentOfViewType;

node_modules/embla-carousel/components/Plugins.d.ts

@@ -0,0 +1,16 @@
+import { CreateOptionsType, LooseOptionsType } from './Options';
+import { EmblaCarouselType } from './EmblaCarousel';
+import { OptionsHandlerType } from './OptionsHandler';
+export type LoosePluginType = {
+    [key: string]: unknown;
+};
+export type CreatePluginType<TypeA extends LoosePluginType, TypeB extends LooseOptionsType> = TypeA & {
+    name: string;
+    options: Partial<CreateOptionsType<TypeB>>;
+    init: (embla: EmblaCarouselType, OptionsHandler: OptionsHandlerType) => void;
+    destroy: () => void;
+};
+export interface EmblaPluginsType {
+    [key: string]: CreatePluginType<LoosePluginType, {}>;
+}
+export type EmblaPluginType = EmblaPluginsType[keyof EmblaPluginsType];

node_modules/embla-carousel/components/PluginsHandler.d.ts

@@ -0,0 +1,8 @@
+import { EmblaCarouselType } from './EmblaCarousel';
+import { OptionsHandlerType } from './OptionsHandler';
+import { EmblaPluginsType, EmblaPluginType } from './Plugins';
+export type PluginsHandlerType = {
+    init: (emblaApi: EmblaCarouselType, plugins: EmblaPluginType[]) => EmblaPluginsType;
+    destroy: () => void;
+};
+export declare function PluginsHandler(optionsHandler: OptionsHandlerType): PluginsHandlerType;

node_modules/embla-carousel/components/ResizeHandler.d.ts

@@ -0,0 +1,13 @@
+import { AxisType } from './Axis';
+import { EmblaCarouselType } from './EmblaCarousel';
+import { EventHandlerType } from './EventHandler';
+import { NodeRectsType } from './NodeRects';
+import { WindowType } from './utils';
+type ResizeHandlerCallbackType = (emblaApi: EmblaCarouselType, entries: ResizeObserverEntry[]) => boolean | void;
+export type ResizeHandlerOptionType = boolean | ResizeHandlerCallbackType;
+export type ResizeHandlerType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+    destroy: () => void;
+};
+export declare function ResizeHandler(container: HTMLElement, eventHandler: EventHandlerType, ownerWindow: WindowType, slides: HTMLElement[], axis: AxisType, watchResize: ResizeHandlerOptionType, nodeRects: NodeRectsType): ResizeHandlerType;
+export {};

node_modules/embla-carousel/components/ScrollBody.d.ts

@@ -0,0 +1,13 @@
+import { Vector1DType } from './Vector1d';
+export type ScrollBodyType = {
+    direction: () => number;
+    duration: () => number;
+    velocity: () => number;
+    seek: (timeStep: number) => ScrollBodyType;
+    settled: () => boolean;
+    useBaseFriction: () => ScrollBodyType;
+    useBaseDuration: () => ScrollBodyType;
+    useFriction: (n: number) => ScrollBodyType;
+    useDuration: (n: number) => ScrollBodyType;
+};
+export declare function ScrollBody(location: Vector1DType, offsetLocation: Vector1DType, previousLocation: Vector1DType, target: Vector1DType, baseDuration: number, baseFriction: number): ScrollBodyType;

node_modules/embla-carousel/components/ScrollBounds.d.ts

@@ -0,0 +1,10 @@
+import { LimitType } from './Limit';
+import { ScrollBodyType } from './ScrollBody';
+import { Vector1DType } from './Vector1d';
+import { PercentOfViewType } from './PercentOfView';
+export type ScrollBoundsType = {
+    shouldConstrain: () => boolean;
+    constrain: (pointerDown: boolean) => void;
+    toggleActive: (active: boolean) => void;
+};
+export declare function ScrollBounds(limit: LimitType, location: Vector1DType, target: Vector1DType, scrollBody: ScrollBodyType, percentOfView: PercentOfViewType): ScrollBoundsType;

node_modules/embla-carousel/components/ScrollContain.d.ts

@@ -0,0 +1,7 @@
+import { LimitType } from './Limit';
+export type ScrollContainOptionType = false | 'trimSnaps' | 'keepSnaps';
+export type ScrollContainType = {
+    snapsContained: number[];
+    scrollContainLimit: LimitType;
+};
+export declare function ScrollContain(viewSize: number, contentSize: number, snapsAligned: number[], containScroll: ScrollContainOptionType, pixelTolerance: number): ScrollContainType;

node_modules/embla-carousel/components/ScrollLimit.d.ts

@@ -0,0 +1,5 @@
+import { LimitType } from './Limit';
+export type ScrollLimitType = {
+    limit: LimitType;
+};
+export declare function ScrollLimit(contentSize: number, scrollSnaps: number[], loop: boolean): ScrollLimitType;

node_modules/embla-carousel/components/ScrollLooper.d.ts

@@ -0,0 +1,6 @@
+import { LimitType } from './Limit';
+import { Vector1DType } from './Vector1d';
+export type ScrollLooperType = {
+    loop: (direction: number) => void;
+};
+export declare function ScrollLooper(contentSize: number, limit: LimitType, location: Vector1DType, vectors: Vector1DType[]): ScrollLooperType;

node_modules/embla-carousel/components/ScrollProgress.d.ts

@@ -0,0 +1,5 @@
+import { LimitType } from './Limit';
+export type ScrollProgressType = {
+    get: (n: number) => number;
+};
+export declare function ScrollProgress(limit: LimitType): ScrollProgressType;

node_modules/embla-carousel/components/ScrollSnaps.d.ts

@@ -0,0 +1,9 @@
+import { AlignmentType } from './Alignment';
+import { AxisType } from './Axis';
+import { NodeRectType } from './NodeRects';
+import { SlidesToScrollType } from './SlidesToScroll';
+export type ScrollSnapsType = {
+    snaps: number[];
+    snapsAligned: number[];
+};
+export declare function ScrollSnaps(axis: AxisType, alignment: AlignmentType, containerRect: NodeRectType, slideRects: NodeRectType[], slidesToScroll: SlidesToScrollType): ScrollSnapsType;

node_modules/embla-carousel/components/ScrollTarget.d.ts

@@ -0,0 +1,12 @@
+import { LimitType } from './Limit';
+import { Vector1DType } from './Vector1d';
+export type TargetType = {
+    distance: number;
+    index: number;
+};
+export type ScrollTargetType = {
+    byIndex: (target: number, direction: number) => TargetType;
+    byDistance: (force: number, snap: boolean) => TargetType;
+    shortcut: (target: number, direction: number) => number;
+};
+export declare function ScrollTarget(loop: boolean, scrollSnaps: number[], contentSize: number, limit: LimitType, targetVector: Vector1DType): ScrollTargetType;

node_modules/embla-carousel/components/ScrollTo.d.ts

@@ -0,0 +1,11 @@
+import { AnimationsType } from './Animations';
+import { CounterType } from './Counter';
+import { EventHandlerType } from './EventHandler';
+import { ScrollBodyType } from './ScrollBody';
+import { ScrollTargetType } from './ScrollTarget';
+import { Vector1DType } from './Vector1d';
+export type ScrollToType = {
+    distance: (n: number, snap: boolean) => void;
+    index: (n: number, direction: number) => void;
+};
+export declare function ScrollTo(animation: AnimationsType, indexCurrent: CounterType, indexPrevious: CounterType, scrollBody: ScrollBodyType, scrollTarget: ScrollTargetType, targetVector: Vector1DType, eventHandler: EventHandlerType): ScrollToType;

node_modules/embla-carousel/components/SlideFocus.d.ts

@@ -0,0 +1,13 @@
+import { EmblaCarouselType } from './EmblaCarousel';
+import { EventHandlerType } from './EventHandler';
+import { EventStoreType } from './EventStore';
+import { ScrollBodyType } from './ScrollBody';
+import { ScrollToType } from './ScrollTo';
+import { SlideRegistryType } from './SlideRegistry';
+type FocusHandlerCallbackType = (emblaApi: EmblaCarouselType, evt: FocusEvent) => boolean | void;
+export type FocusHandlerOptionType = boolean | FocusHandlerCallbackType;
+export type SlideFocusType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+};
+export declare function SlideFocus(root: HTMLElement, slides: HTMLElement[], slideRegistry: SlideRegistryType['slideRegistry'], scrollTo: ScrollToType, scrollBody: ScrollBodyType, eventStore: EventStoreType, eventHandler: EventHandlerType, watchFocus: FocusHandlerOptionType): SlideFocusType;
+export {};

node_modules/embla-carousel/components/SlideLooper.d.ts

@@ -0,0 +1,18 @@
+import { AxisType } from './Axis';
+import { Vector1DType } from './Vector1d';
+import { TranslateType } from './Translate';
+type LoopPointType = {
+    loopPoint: number;
+    index: number;
+    translate: TranslateType;
+    slideLocation: Vector1DType;
+    target: () => number;
+};
+export type SlideLooperType = {
+    canLoop: () => boolean;
+    clear: () => void;
+    loop: () => void;
+    loopPoints: LoopPointType[];
+};
+export declare function SlideLooper(axis: AxisType, viewSize: number, contentSize: number, slideSizes: number[], slideSizesWithGaps: number[], snaps: number[], scrollSnaps: number[], location: Vector1DType, slides: HTMLElement[]): SlideLooperType;
+export {};

node_modules/embla-carousel/components/SlideRegistry.d.ts

@@ -0,0 +1,7 @@
+import { LimitType } from './Limit';
+import { ScrollContainOptionType } from './ScrollContain';
+import { SlidesToScrollType } from './SlidesToScroll';
+export type SlideRegistryType = {
+    slideRegistry: number[][];
+};
+export declare function SlideRegistry(containSnaps: boolean, containScroll: ScrollContainOptionType, scrollSnaps: number[], scrollContainLimit: LimitType, slidesToScroll: SlidesToScrollType, slideIndexes: number[]): SlideRegistryType;

node_modules/embla-carousel/components/SlideSizes.d.ts

@@ -0,0 +1,10 @@
+import { AxisType } from './Axis';
+import { NodeRectType } from './NodeRects';
+import { WindowType } from './utils';
+export type SlideSizesType = {
+    slideSizes: number[];
+    slideSizesWithGaps: number[];
+    startGap: number;
+    endGap: number;
+};
+export declare function SlideSizes(axis: AxisType, containerRect: NodeRectType, slideRects: NodeRectType[], slides: HTMLElement[], readEdgeGap: boolean, ownerWindow: WindowType): SlideSizesType;

node_modules/embla-carousel/components/SlidesHandler.d.ts

@@ -0,0 +1,10 @@
+import { EmblaCarouselType } from './EmblaCarousel';
+import { EventHandlerType } from './EventHandler';
+type SlidesHandlerCallbackType = (emblaApi: EmblaCarouselType, mutations: MutationRecord[]) => boolean | void;
+export type SlidesHandlerOptionType = boolean | SlidesHandlerCallbackType;
+export type SlidesHandlerType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+    destroy: () => void;
+};
+export declare function SlidesHandler(container: HTMLElement, eventHandler: EventHandlerType, watchSlides: SlidesHandlerOptionType): SlidesHandlerType;
+export {};

node_modules/embla-carousel/components/SlidesInView.d.ts

@@ -0,0 +1,8 @@
+import { EventHandlerType } from './EventHandler';
+export type SlidesInViewOptionsType = IntersectionObserverInit['threshold'];
+export type SlidesInViewType = {
+    init: () => void;
+    destroy: () => void;
+    get: (inView?: boolean) => number[];
+};
+export declare function SlidesInView(container: HTMLElement, slides: HTMLElement[], eventHandler: EventHandlerType, threshold: SlidesInViewOptionsType): SlidesInViewType;

node_modules/embla-carousel/components/SlidesToScroll.d.ts

@@ -0,0 +1,7 @@
+import { AxisType } from './Axis';
+import { NodeRectType } from './NodeRects';
+export type SlidesToScrollOptionType = 'auto' | number;
+export type SlidesToScrollType = {
+    groupSlides: <Type>(array: Type[]) => Type[][];
+};
+export declare function SlidesToScroll(axis: AxisType, viewSize: number, slidesToScroll: SlidesToScrollOptionType, loop: boolean, containerRect: NodeRectType, slideRects: NodeRectType[], startGap: number, endGap: number, pixelTolerance: number): SlidesToScrollType;

node_modules/embla-carousel/components/Translate.d.ts

@@ -0,0 +1,7 @@
+import { AxisType } from './Axis';
+export type TranslateType = {
+    clear: () => void;
+    to: (target: number) => void;
+    toggleActive: (active: boolean) => void;
+};
+export declare function Translate(axis: AxisType, container: HTMLElement): TranslateType;

node_modules/embla-carousel/components/Vector1d.d.ts

@@ -0,0 +1,7 @@
+export type Vector1DType = {
+    get: () => number;
+    set: (n: Vector1DType | number) => void;
+    add: (n: Vector1DType | number) => void;
+    subtract: (n: Vector1DType | number) => void;
+};
+export declare function Vector1D(initialValue: number): Vector1DType;

node_modules/embla-carousel/components/utils.d.ts

@@ -0,0 +1,18 @@
+import { PointerEventType } from './DragTracker';
+export type WindowType = Window & typeof globalThis;
+export declare function isNumber(subject: unknown): subject is number;
+export declare function isString(subject: unknown): subject is string;
+export declare function isBoolean(subject: unknown): subject is boolean;
+export declare function isObject(subject: unknown): subject is Record<string, unknown>;
+export declare function mathAbs(n: number): number;
+export declare function mathSign(n: number): number;
+export declare function deltaAbs(valueB: number, valueA: number): number;
+export declare function factorAbs(valueB: number, valueA: number): number;
+export declare function arrayKeys<Type>(array: Type[]): number[];
+export declare function arrayLast<Type>(array: Type[]): Type;
+export declare function arrayLastIndex<Type>(array: Type[]): number;
+export declare function arrayIsLastIndex<Type>(array: Type[], index: number): boolean;
+export declare function arrayFromNumber(n: number, startAt?: number): number[];
+export declare function objectKeys<Type extends object>(object: Type): string[];
+export declare function objectsMergeDeep(objectA: Record<string, unknown>, objectB: Record<string, unknown>): Record<string, unknown>;
+export declare function isMouseEvent(evt: PointerEventType, ownerWindow: WindowType): evt is MouseEvent;