lightgallery 2.9.0 → 3.0.0-beta.3

package/dist/types/headless/share-urls.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Share link builders + Web Share payload logic for the share plugin. The
+ * URL builders are ported from the 2.x `lg-*-share-utils` files as pure
+ * functions — the page URL fallback is a parameter instead of
+ * `window.location.href`. The Web Share helpers are pure too: the runtime
+ * hands in a structural `navigator` so nothing here touches the DOM.
+ */
+/**
+ * Structural slice of a gallery item the share builders read — kept
+ * narrow so any runtime's item shape (including the 2.x vanilla one)
+ * satisfies it without casts.
+ */
+export interface ShareItemFields {
+    src?: string;
+    alt?: string;
+    title?: string;
+    shareUrl?: string;
+    facebookShareUrl?: string;
+    tweetText?: string;
+    twitterShareUrl?: string;
+    pinterestShareUrl?: string;
+    pinterestText?: string;
+}
+export declare function getFacebookShareLink(item: ShareItemFields, currentUrl: string): string;
+/**
+ * X (formerly Twitter) intent URL. The 2.x `tweetText`/`twitterShareUrl`
+ * item fields (and their `data-tweet-text` style attributes) keep working —
+ * only the target changed. Unlike the 2.x builder the text is URL-encoded.
+ */
+export declare function getXShareLink(item: ShareItemFields, currentUrl: string): string;
+/** @deprecated Renamed — use {@link getXShareLink} (X intent URL). */
+export declare const getTwitterShareLink: typeof getXShareLink;
+export declare function getPinterestShareLink(item: ShareItemFields, currentUrl: string): string;
+/**
+ * Data handed to `navigator.share`. URL-sharing only by design: attaching
+ * the image itself would require fetching cross-origin bytes (a proxy),
+ * which the share plugin will not do.
+ */
+export interface SharePayload {
+    title?: string;
+    text?: string;
+    url: string;
+}
+/**
+ * Build the Web Share payload for a slide. The per-item `shareUrl` wins,
+ * then the network-specific share URLs, then the page URL; text falls back
+ * from the tweet text to the Pinterest description.
+ */
+export declare function getSharePayload(item: ShareItemFields, currentUrl: string): SharePayload;
+/** Structural slice of `navigator` the Web Share decision needs. */
+export interface NativeShareNavigator {
+    share?: (data: SharePayload) => Promise<void>;
+    canShare?: (data: SharePayload) => boolean;
+}
+/**
+ * True when the runtime can hand this payload to the OS share sheet.
+ * Feature-detected and never load-bearing: no `navigator.share` (or a
+ * `canShare` veto) simply keeps the branded dropdown menu.
+ */
+export declare function canNativeShare(nav: NativeShareNavigator | undefined | null, payload: SharePayload): boolean;

package/dist/types/headless/spring.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Gesture-release physics: momentum projection and a damped-spring
+ * stepper. Releases compute where momentum would land (`project`),
+ * clamp that into bounds, and animate there with a spring seeded by the
+ * live release velocity — velocity stays continuous across the
+ * finger-lift boundary, which is most of what native feel is.
+ *
+ * The stepper advances the standard damped harmonic oscillator by its
+ * closed-form solution over each frame, so step size never affects the
+ * trajectory and the state (position + velocity) can re-seed a new
+ * spring at any interruption point.
+ */
+export interface SpringState {
+    position: number;
+    /** px per ms (same unit as the windowed gesture velocity). */
+    velocity: number;
+}
+export interface SpringConfig {
+    /** 1 = never overshoot; < 1 overshoots and returns. */
+    dampingRatio?: number;
+    /** Rad/s — higher settles faster. */
+    naturalFrequency?: number;
+}
+/** Settling toward an in-bounds target: no overshoot. */
+export declare const SPRING_SETTLE_DAMPING = 1;
+/** Settling against a clamped bound: one soft bounce. */
+export declare const SPRING_BOUNCE_DAMPING = 0.82;
+export declare const SPRING_NATURAL_FREQUENCY = 12;
+/**
+ * Momentum projection: how far a release keeps traveling when it loses
+ * `1 - decelerationRate` of its velocity every millisecond (the classic
+ * scroll-view constant; 0.995 ≈ half a percent per ms).
+ */
+export declare const DECELERATION_RATE = 0.995;
+export declare function project(velocity: number, decelerationRate?: number): number;
+/**
+ * Advance a spring toward `target` by `dtMs`, exactly (closed form with
+ * the current state as initial conditions).
+ */
+export declare function stepSpring(state: SpringState, target: number, dtMs: number, { dampingRatio, naturalFrequency, }?: SpringConfig): SpringState;
+/** Whether a spring is close enough to stop animating. */
+export declare function isSpringSettled(state: SpringState, target: number, restDelta?: number, restVelocity?: number): boolean;

package/dist/types/headless/state.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Framework-free gallery state machine. React (and later Angular/Vue) wrap
+ * this with their own reactivity; every transition lives here so behavior is
+ * identical across frameworks and testable without any DOM.
+ */
+export type SlideDirection = 'next' | 'prev';
+export interface GalleryState {
+    open: boolean;
+    currentIndex: number;
+    previousIndex: number;
+    slidesCount: number;
+    loop: boolean;
+    /**
+     * True once any slide media has finished loading (or failed) since the
+     * gallery opened — 2.x `lGalleryOn`. Distinguishes the first slide
+     * (backdrop/zoom entrance, no slide animation) from navigation.
+     */
+    galleryOn: boolean;
+    /**
+     * True while a slide transition runs — 2.x `lgBusy`. Navigation actions
+     * are ignored until `TRANSITION_END`.
+     */
+    transitioning: boolean;
+    /** Direction of the last navigation; drives prev/next slide classes. */
+    slideDirection?: SlideDirection;
+    /** Indexes whose media has fully loaded (`lg-complete`). */
+    loadedSlides: ReadonlySet<number>;
+}
+export type GalleryAction = {
+    type: 'OPEN';
+    index?: number;
+} | {
+    type: 'CLOSE';
+} | {
+    type: 'GO_TO';
+    index: number;
+    direction?: SlideDirection;
+} | {
+    type: 'NEXT';
+} | {
+    type: 'PREV';
+} | {
+    type: 'SET_SLIDES_COUNT';
+    count: number;
+} | {
+    type: 'SET_LOOP';
+    loop: boolean;
+} | {
+    type: 'SLIDE_LOADED';
+    index: number;
+} | {
+    type: 'SLIDE_ERROR';
+    index: number;
+} | {
+    type: 'TRANSITION_END';
+};
+export interface CreateGalleryStateOptions {
+    slidesCount: number;
+    loop?: boolean;
+    index?: number;
+}
+export declare function createGalleryState(options: CreateGalleryStateOptions): GalleryState;
+export declare function galleryReducer(state: GalleryState, action: GalleryAction): GalleryState;

package/dist/types/headless/thumb-math.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Thumbnail strip math (2.x `animateThumb`/`getPossibleTransformX`) as pure
+ * functions for the thumbnail plugin.
+ */
+import type { ResolvedGalleryDirection } from './settings';
+export type ThumbPagerPosition = 'left' | 'middle' | 'right';
+/**
+ * Rubber-band a raw strip translate (plan 010 physics): inside the
+ * bounds it passes through; beyond an edge the overshoot compresses by
+ * the shared edge friction so the strip resists like the slide gestures.
+ * The release spring pulls the compressed overshoot back to the bound.
+ */
+export declare function getElasticThumbTranslate(raw: number, totalWidth: number, stripWidth: number, friction?: number): number;
+export declare function getThumbTotalWidth(count: number, thumbWidth: number, thumbMargin: number): number;
+/** Clamp a strip translate into `[0, total - visible]` (never negative). */
+export declare function clampThumbTranslate(translate: number, totalWidth: number, stripWidth: number): number;
+/**
+ * The window of thumbnails that must exist in the DOM for a given strip
+ * translate (plan 010 virtualization): the visible range plus `overscan`
+ * thumbs on each side, with leading/trailing pad widths so the strip keeps
+ * its full scroll geometry while only the window renders.
+ */
+export interface ThumbWindow {
+    /** First rendered thumb index (inclusive). */
+    start: number;
+    /** Last rendered thumb index (inclusive). */
+    end: number;
+    /** Spacer width (px) standing in for the thumbs before `start`. */
+    leadingPad: number;
+    /** Spacer width (px) standing in for the thumbs after `end`. */
+    trailingPad: number;
+}
+/**
+ * Compute the rendered thumb window from the strip translate. `overscan`
+ * is the number of extra thumbs kept mounted on each side of the visible
+ * range ('auto' derives one extra viewport per side — enough that a full
+ * flick lands on already-rendered thumbs).
+ */
+export declare function getThumbWindow(options: {
+    translate: number;
+    stripWidth: number;
+    thumbWidth: number;
+    thumbMargin: number;
+    count: number;
+    overscan?: number | 'auto';
+}): ThumbWindow;
+/**
+ * Window covering a fling's whole flight path (plan 010): the union of
+ * the windows at the start and end translates, so a released strip never
+ * glides over unrendered thumbs — the destination is known at release.
+ */
+export declare function getThumbCorridorWindow(options: {
+    from: number;
+    to: number;
+    stripWidth: number;
+    thumbWidth: number;
+    thumbMargin: number;
+    count: number;
+    overscan?: number | 'auto';
+}): ThumbWindow;
+/**
+ * Which slide a live strip translate selects in scrub mode (the strip
+ * drives the gallery while it moves). Proportional: the strip's full
+ * scroll travel maps onto the full index range, so the FIRST and LAST
+ * slides are always reachable — a fixed pager-point inverse cannot
+ * reach the ends, because the clamped translate never brings them
+ * under the pager slot. For long strips this converges to one index
+ * per thumb unit of travel. Translate is the logical strip scalar
+ * (RTL-agnostic); elastic overshoot clamps, pinning the ends.
+ * Exact inverse: {@link getScrubThumbTranslate}.
+ */
+export declare function getScrubThumbIndex(translate: number, totalWidth: number, stripWidth: number, count: number): number;
+/**
+ * Strip translate at which {@link getScrubThumbIndex} resolves exactly
+ * `index` — for aligning the strip to the scrubbed slide after the
+ * release glide settles. (Not `getActiveThumbTranslate`: that pager
+ * alignment is a different map and would re-resolve to a neighboring
+ * index near the ends.)
+ */
+export declare function getScrubThumbTranslate(index: number, totalWidth: number, stripWidth: number, count: number): number;
+/**
+ * Strip translate that brings the active thumbnail to the pager position
+ * (2.x `animateThumb`, including its off-by-one `- 1`).
+ */
+export declare function getActiveThumbTranslate(index: number, thumbWidth: number, thumbMargin: number, stripWidth: number, totalWidth: number, pagerPosition: ThumbPagerPosition, direction?: ResolvedGalleryDirection): number;

package/dist/types/headless/toolbar-overflow.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Toolbar overflow: when the toolbar's icon buttons do not fit on one row
+ * beside the counter, the lowest-priority buttons move into a "More
+ * options" menu. Pure layout arithmetic over measured widths; each runtime
+ * measures its own DOM, applies the result and renders the menu.
+ */
+/** Priority of a button that never moves into the menu (close). */
+export declare const TOOLBAR_PINNED: number;
+/** Priority of a button the table does not know (custom plugin buttons). */
+export declare const TOOLBAR_DEFAULT_PRIORITY = 20;
+/** Overflow priority of a toolbar button from its class names. */
+export declare function getToolbarItemPriority(classList: Iterable<string>): number;
+export interface ToolbarOverflowItem {
+    /** Measured width, px. */
+    width: number;
+    /** From {@link getToolbarItemPriority}; higher stays longer. */
+    priority: number;
+}
+export interface ToolbarOverflowInput {
+    /** Width of the toolbar row, px. */
+    available: number;
+    /** Width taken by content that never moves (the counter), px. */
+    reserved: number;
+    /** Width of the More button, px. */
+    moreWidth: number;
+    /** The toolbar's icon buttons, in DOM order. */
+    items: readonly ToolbarOverflowItem[];
+}
+/**
+ * Indices (in DOM order) of the buttons that move into the menu; empty
+ * when everything fits, or when the toolbar has no width yet (not laid
+ * out). Lowest priority moves first; among equals, the button later in
+ * DOM order goes first, which is the one furthest from the close button.
+ * The More button's own width is paid as soon as anything moves.
+ */
+export declare function getToolbarOverflow({ available, reserved, moreWidth, items, }: ToolbarOverflowInput): number[];
+/**
+ * Whether a click's event path runs through the toolbar. Clicks there are
+ * controls, not a tap on the backdrop: Medium zoom closes on the latter
+ * only. The path (`event.composedPath()`) still lists a More menu item the
+ * click already removed from the document.
+ */
+export declare function isToolbarEventPath(path: readonly unknown[]): boolean;
+/** What the dismissal of a toolbar menu reads from the dismissing press. */
+export interface MenuDismissEvent {
+    target: unknown;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+/**
+ * A press outside an open toolbar menu (the More options menu, the share
+ * dropdown) dismisses it. A press on a control passes through, so one
+ * click on another toolbar button both dismisses the menu and runs the
+ * button. A press on the backdrop around the slide is consumed instead:
+ * there the gallery's own tap-to-close and drag would fire, and
+ * dismissing a menu must not also close the gallery. Cancelling the
+ * pointerdown suppresses the compatibility mouse events the vanilla
+ * runtime listens to; stopping it keeps the pointer-driven runtimes'
+ * handlers from arming. Returns whether the press was consumed.
+ */
+export declare function consumeBackdropPress(event: MenuDismissEvent): boolean;

package/dist/types/headless/transition.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Settle gate for a CSS transition: call back once the transition of
+ * `property` on `element` has actually ended.
+ *
+ * A fixed timer measured from the moment the target value is applied
+ * lands at the same wall-clock offset whether or not the transition has
+ * started, but the transition only starts at the first style recalc
+ * after the value lands — on a busy main thread (a gallery's first
+ * layout, a big thumbnail decode) that can be well past the offset.
+ * Anything gated on the fixed timer then fires mid-flight.
+ *
+ * Contract:
+ * - No `transitionstart` within `fallbackMs` → the element is not
+ *   transitioning (reduced motion, identity transform, no CSS) and the
+ *   gate settles on the timer, exactly like the fixed timer did.
+ * - `transitionstart` re-bases the timer on the real start; `transitionend`
+ *   settles immediately. Interrupted transitions (`transitioncancel`)
+ *   leave the timer running so a restart still settles in time.
+ * - Events bubbling from descendants, or for other properties, are
+ *   ignored. The callback runs at most once.
+ *
+ * Returns a disposer; disposing after settle is a no-op.
+ */
+export interface TransitionSettleEvent {
+    target: unknown;
+    propertyName?: string;
+}
+/** Structural slice of a DOM element: headless carries no DOM lib. */
+export interface TransitionSettleTarget {
+    addEventListener(type: string, listener: (event: TransitionSettleEvent) => void): void;
+    removeEventListener(type: string, listener: (event: TransitionSettleEvent) => void): void;
+}
+export declare function onTransitionSettle(element: TransitionSettleTarget, property: string, fallbackMs: number, callback: () => void): () => void;

package/dist/types/headless/velocity.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Rolling-window velocity tracking. Release decisions must read the
+ * velocity of the gesture's final instant, not its whole-gesture
+ * average: a drag that pauses and then flicks reads fast, and a drag
+ * that ends resting reads zero. Sessions push a sample per move; the
+ * release reads the window ending at the release timestamp.
+ */
+export interface VelocitySample {
+    x: number;
+    y: number;
+    /** Timestamp in ms (same clock as the release read). */
+    t: number;
+}
+export interface Velocity {
+    /** px/ms, signed. */
+    x: number;
+    y: number;
+}
+/** How far back a release looks when reading the gesture velocity. */
+export declare const VELOCITY_WINDOW_MS = 100;
+/**
+ * Append a sample, pruning everything older than the window — the
+ * buffer stays a handful of entries regardless of gesture length.
+ */
+export declare function pushVelocitySample(samples: readonly VelocitySample[], sample: VelocitySample, windowMs?: number): VelocitySample[];
+/**
+ * Velocity (px/ms per axis) over the samples inside the window ending
+ * at `releaseTime`. Fewer than two recent samples — the finger rested
+ * before lifting — reads as zero, as does sub-pixel drift.
+ */
+export declare function getWindowedVelocity(samples: readonly VelocitySample[], releaseTime: number, windowMs?: number): Velocity;

package/dist/types/headless/video-urls.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Video URL detection and embed-URL builders, ported from 2.x
+ * `utils.isVideo` (`src/lg-utils.ts`) and `lg-video-utils.ts` as pure
+ * functions. The video plugin renders the returned URLs; nothing here
+ * touches the DOM.
+ */
+export interface VideoInfo {
+    /** RegExp match parts: `[match, videoId, urlParams?]`. */
+    youtube?: string[];
+    vimeo?: string[];
+    /** RegExp match parts; index 4 is the media id. */
+    wistia?: string[];
+    html5?: boolean;
+}
+export type PlayerParams = Record<string, string | number | boolean> | boolean;
+/** Detect the video provider for a src URL (2.x `utils.isVideo`). */
+export declare function getVideoInfo(src: string | undefined, hasHtml5Video: boolean): VideoInfo | undefined;
+/** Serialize params as a query string (2.x `param`). */
+export declare function param(obj: Record<string, string | number | boolean>): string;
+/** Parse `?a=b&c=d` into an object (2.x `paramsToObject`). */
+export declare function paramsToObject(url: string): Record<string, string>;
+export declare function isYouTubeNoCookie(url: string): boolean;
+/**
+ * YouTube embed URL. Precedence (2.x parity): defaults < settings < params
+ * already present on the slide URL. The privacy-enhanced
+ * `youtube-nocookie.com` host is the default; pass `preferNoCookie: false`
+ * (the `youTubeNoCookie` setting) to revert to `youtube.com`. A slide URL
+ * that already names the nocookie host always keeps it.
+ */
+export declare function getYouTubeEmbedUrl(videoInfo: VideoInfo, playerParamsSettings: PlayerParams, srcUrl: string, preferNoCookie?: boolean): string | undefined;
+/**
+ * YouTube's public thumbnail endpoint for a detected video — the one
+ * provider poster that needs no API call. (Vimeo/Wistia poster endpoints
+ * require a fetch/auth, so their facades rely on the item's own
+ * poster/thumb — see getFacadePoster.)
+ */
+export declare function getYouTubePosterUrl(videoInfo: VideoInfo | undefined): string | undefined;
+/**
+ * Poster for a provider-video facade (lite embed): the explicit item
+ * poster wins, then the YouTube thumbnail endpoint (when enabled), then
+ * the item's grid thumb — for Vimeo galleries the vimeoThumbnail plugin
+ * rewrites `thumb` to the oEmbed thumbnail, which feeds this chain.
+ * HTML5 slides never get a synthesized poster (unchanged 2.x behavior);
+ * a provider slide with no resolvable poster returns undefined and keeps
+ * the eager-iframe path.
+ */
+export declare function getFacadePoster(item: {
+    poster?: string;
+    thumb?: string;
+}, videoInfo: VideoInfo | undefined, loadYouTubePoster: boolean): string | undefined;
+/**
+ * Provider player-API script URLs, loaded on demand at first play (the
+ * vanilla runtime's control paths need them; the framework bindings drive
+ * players via postMessage and load nothing).
+ */
+export declare const VIMEO_PLAYER_SCRIPT_URL = "https://player.vimeo.com/api/player.js";
+export declare const WISTIA_PLAYER_SCRIPT_URL = "https://fast.wistia.com/assets/external/E-v1.js";
+/**
+ * Vimeo embed URL, including the private-video hash handling (2.x
+ * `getVimeoURLParams`).
+ */
+export declare function getVimeoEmbedUrl(videoInfo: VideoInfo, playerParamsSettings: PlayerParams): string | undefined;
+/** Wistia embed URL. */
+export declare function getWistiaEmbedUrl(videoInfo: VideoInfo, playerParamsSettings: PlayerParams): string | undefined;

package/dist/types/headless/zoom-math.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Zoom math for the zoom plugin, ported from the 2.x zoom
+ * plugin's scale/position logic as pure functions: scale stepping and
+ * clamping, actual-size scale, point-anchored zooming, pinch scale and
+ * pan bounds. The React plugin writes the resulting transforms to the DOM.
+ */
+export interface ZoomPan {
+    x: number;
+    y: number;
+}
+export interface PanBounds {
+    maxX: number;
+    maxY: number;
+}
+/**
+ * How far a zoomed image may pan before its edge would detach from the
+ * container edge. At scale <= 1 the image cannot pan at all.
+ */
+export declare function getPanBounds(imageWidth: number, imageHeight: number, containerWidth: number, containerHeight: number, scale: number): PanBounds;
+export declare function clampPan(pan: ZoomPan, bounds: PanBounds): ZoomPan;
+/**
+ * Scale at which the image renders at its natural pixel size (2.x
+ * `getCurrentImageActualSizeScale`, with its `|| 2` fallback).
+ */
+export declare function getActualSizeScale(naturalWidth: number, renderedWidth: number): number;
+/** Clamp a target scale: never below 1; capped unless `infiniteZoom`. */
+export declare function clampScale(scale: number, maxScale: number, infiniteZoom: boolean): number;
+/**
+ * Pan that keeps the given point (relative to the container center)
+ * anchored while the scale changes — used for double-click/tap zoom and
+ * pinch focal points.
+ */
+export declare function getPointZoomPan(point: ZoomPan, prevPan: ZoomPan, prevScale: number, newScale: number): ZoomPan;
+/**
+ * Stage-aware pan clamp. X is symmetric. The pan-up floor on Y extends
+ * past the content box by `stageBottomExtra` — the components strip
+ * (thumbnails + caption) vacates when zoomed, so the visible stage
+ * reaches the SCREEN bottom and the image may ride up until its bottom
+ * edge meets it; a plain symmetric clamp would strand a strip-height
+ * gap of black. Inversion-guarded (min against +maxY) for images
+ * taller than the content box but shorter than the full stage.
+ */
+export declare function clampPanToStage(pan: ZoomPan, bounds: PanBounds, stageBottomExtra: number): ZoomPan;
+/**
+ * Pan during a pinch: the focal zoom projection translated by the
+ * midpoint's travel — the image point between the fingers stays
+ * between the fingers wherever they go (iOS fused
+ * zoom-and-pan; two fingers moving together pan without zooming).
+ */
+export declare function getPinchPan(currentMid: ZoomPan, startMid: ZoomPan, startPan: ZoomPan, startScale: number, scale: number): ZoomPan;
+/** Distance between two pointers (pinch measurement). */
+export declare function getPointerDistance(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * Continuous resistance below fit scale — replaces the 2.x hard 0.5
+ * floor: past the boundary the scale keeps moving at 15% per unit.
+ */
+export declare const PINCH_UNDER_FRICTION = 0.15;
+/**
+ * Very stiff resistance beyond actual size instead of a hard stop;
+ * the release spring lands back inside bounds. `infiniteZoom` disables
+ * this boundary entirely.
+ */
+export declare const PINCH_OVER_FRICTION = 0.05;
+/**
+ * Scale during a pinch: proportional to the distance ratio, with
+ * friction (not clamps) at both boundaries. When pinch-to-close is
+ * armed, the under-fit squeeze is free — the shrink IS the close
+ * affordance; the release verdict is {@link shouldCloseOnPinch}.
+ */
+export declare function getPinchScale(startDistance: number, currentDistance: number, startScale: number, maxScale: number, infiniteZoom: boolean, pinchToCloseArmed?: boolean): number;
+/**
+ * Pinch-to-close verdict (iOS Photos signature): a pinch released
+ * below fit closes ONLY when the whole gesture stayed at or under fit
+ * — an over-then-under pinch is a zoom correction, not a dismissal.
+ * `maxGestureScale` is the largest scale seen since the pinch started
+ * (seeded with the start scale).
+ */
+export declare function shouldCloseOnPinch(input: {
+    scale: number;
+    maxGestureScale: number;
+    pinchToClose: boolean;
+    closable: boolean;
+}): boolean;

package/{index.d.ts → dist/types/index.d.ts}

@@ -1,4 +1,9 @@
-import { LightGallerySettings } from './lg-settings';
-import { LightGallery } from './lightgallery';
-declare function lightGallery(el: HTMLElement, options?: LightGallerySettings): LightGallery;
-export default lightGallery;
+import { LightGallerySettings } from './lg-settings';
+import { LightGallery } from './lightgallery';
+declare function lightGallery(el: HTMLElement, options?: LightGallerySettings): LightGallery;
+declare namespace lightGallery {
+    var setLicenseKey: typeof import("./headless/index").setLicenseKey;
+}
+export default lightGallery;
+export type { LightGallery };
+export type { LgIconName, LgIcons } from './lg-icons';