@redot-src/glare 1.0.0 → 1.1.0

package/dist/i18n.d.ts

@@ -0,0 +1,4 @@
+import type { GlareOptions, I18nDict } from './types';
+export declare const i18nEn: I18nDict;
+/** Resolves the active dictionary: built-in English, then `i18n.en`, then `i18n[lang]`. */
+export declare function getDict(opts: GlareOptions): I18nDict;

package/dist/icons.d.ts

@@ -1,15 +1,14 @@
 export declare const icons: {
-    readonly close: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"M18 6 6 18\"/><path d=\"m6 6 12 12\"/></svg>";
-    readonly next: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"m9 18 6-6-6-6\"/></svg>";
-    readonly prev: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"m15 18-6-6 6-6\"/></svg>";
-    readonly zoomIn: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><circle cx=\"11\" cy=\"11\" r=\"8\"/><path d=\"m21 21-4.3-4.3\"/><path d=\"M11 8v6\"/><path d=\"M8 11h6\"/></svg>";
-    readonly zoomOut: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><circle cx=\"11\" cy=\"11\" r=\"8\"/><path d=\"m21 21-4.3-4.3\"/><path d=\"M8 11h6\"/></svg>";
-    readonly download: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4\"/><polyline points=\"7 10 12 15 17 10\"/><line x1=\"12\" x2=\"12\" y1=\"15\" y2=\"3\"/></svg>";
-    readonly share: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><circle cx=\"18\" cy=\"5\" r=\"3\"/><circle cx=\"6\" cy=\"12\" r=\"3\"/><circle cx=\"18\" cy=\"19\" r=\"3\"/><line x1=\"8.59\" x2=\"15.42\" y1=\"13.51\" y2=\"17.49\"/><line x1=\"15.41\" x2=\"8.59\" y1=\"6.51\" y2=\"10.49\"/></svg>";
-    readonly thumbs: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\"/><path d=\"M3 9h18\"/><path d=\"M9 21V9\"/></svg>";
-    readonly play: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><polygon points=\"6 3 20 12 6 21 6 3\"/></svg>";
-    readonly pause: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><rect width=\"4\" height=\"16\" x=\"6\" y=\"4\"/><rect width=\"4\" height=\"16\" x=\"14\" y=\"4\"/></svg>";
-    readonly fullscreen: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"M8 3H5a2 2 0 0 0-2 2v3\"/><path d=\"M21 8V5a2 2 0 0 0-2-2h-3\"/><path d=\"M3 16v3a2 2 0 0 0 2 2h3\"/><path d=\"M16 21h3a2 2 0 0 0 2-2v-3\"/></svg>";
-    readonly fullscreenExit: "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\"><path d=\"M8 3v3a2 2 0 0 1-2 2H3\"/><path d=\"M21 8h-3a2 2 0 0 1-2-2V3\"/><path d=\"M3 16h3a2 2 0 0 1 2 2v3\"/><path d=\"M16 21v-3a2 2 0 0 1 2-2h3\"/></svg>";
+    readonly close: string;
+    readonly next: string;
+    readonly prev: string;
+    readonly zoomIn: string;
+    readonly zoomOut: string;
+    readonly download: string;
+    readonly share: string;
+    readonly thumbs: string;
+    readonly play: string;
+    readonly pause: string;
+    readonly fullscreen: string;
+    readonly fullscreenExit: string;
 };
-//# sourceMappingURL=icons.d.ts.map

package/dist/index.d.ts

@@ -1,8 +1,6 @@
-import './styles/glare.css';
-export type { AnimationEffect, AjaxOptions, BoundGroup, ClickAction, ContentType, EventHandler, EventName, FullscreenOptions, HashOptions, I18nDict, IframeOptions, ImageOptions, MediaProvider, GlareInstance, GlareOptions, ShareOptions, SlideItem, SlideSource, SlideshowOptions, ThumbsOptions, ToolbarButton, TouchOptions, TransitionEffect, VideoOptions, } from './types';
-export { defaults, defaultMedia, i18nEn } from './defaults';
-export { Glare, autoBind } from './instance';
-export { detectType, normalizeItem, itemsFromElements } from './media';
-import { Glare } from './instance';
+import { Glare } from './core/glare';
+export type { AjaxOptions, AnimationEffect, BoundGroup, ClickAction, ClickActionName, ContentType, EventHandler, EventName, FullscreenOptions, GlareInstance, GlareOptions, GlareRefs, I18nDict, IframeOptions, ImageOptions, LifecycleEvent, LifecycleHandler, MediaProvider, ResolvedOptions, ShareOptions, SlideEvent, SlideItem, SlideSource, SlideshowOptions, ThumbsOptions, ToolbarButton, TouchOptions, TransitionEffect, VideoOptions, } from './types';
+export type { Point, Zoom, ZoomState } from './core/zoom';
+export { Glare };
+export declare const autoBind: typeof Glare.autoBind;
 export default Glare;
-//# sourceMappingURL=index.d.ts.map

package/dist/media/detect.d.ts

@@ -0,0 +1,4 @@
+import type { ContentType } from '../types';
+/** Guesses the content type from a URL; falls back to `fallback` for unknown URLs. */
+export declare function detectType(src: string, fallback?: ContentType): ContentType;
+export declare function videoMime(src: string): string;

package/dist/media/items.d.ts

@@ -0,0 +1,6 @@
+import type { GlareOptions, SlideItem, SlideSource } from '../types';
+/** Turns a user-provided slide into a normalized `SlideItem`. */
+export declare function normalizeItem(source: SlideSource | string, index: number, opts: GlareOptions): SlideItem;
+/** Reads slide data from trigger elements (`href`, `data-*` attributes, nested `<img>`). */
+export declare function itemsFromElements(elements: HTMLElement[], opts: GlareOptions): SlideItem[];
+export declare function createItems(items: Array<SlideSource | string> | HTMLElement[], opts: GlareOptions): SlideItem[];

package/dist/media/providers.d.ts

@@ -0,0 +1,6 @@
+import type { ContentType, MediaProvider, SlideSource } from '../types';
+export declare const providers: Record<string, MediaProvider>;
+/** Rewrites `src` through the first matching provider, or returns null. */
+export declare function applyProvider(src: string, media: Record<string, MediaProvider> | undefined): Pick<SlideSource, 'src' | 'thumb'> & {
+    type: ContentType;
+} | null;

package/dist/modules/fullscreen.d.ts

@@ -0,0 +1,15 @@
+import type { FullscreenOptions } from '../types';
+import type { Glare } from '../core/glare';
+/** Fullscreen API wrapper with the WebKit fallback still needed by Safari. */
+export declare class Fullscreen {
+    private readonly glare;
+    private readonly container;
+    private readonly offs;
+    constructor(glare: Glare, container: HTMLElement, opts: FullscreenOptions);
+    isFullscreen(): boolean;
+    request(): void;
+    exit(): void;
+    toggle(): void;
+    destroy(): void;
+    private sync;
+}

package/dist/modules/gestures.d.ts

@@ -0,0 +1,45 @@
+import type { TouchOptions } from '../types';
+import type { Zoom } from '../core/zoom';
+export interface GestureHost {
+    zoom: Zoom;
+    touch: TouchOptions;
+    /** The backdrop, dimmed while the stage is dragged vertically. */
+    bg: HTMLElement | null;
+    /** Whether the current slide can be panned when zoomed. */
+    canPan(): boolean;
+    close(): void;
+    next(): void;
+    prev(): void;
+}
+/** Swipe, pan and pinch handling on top of Pointer Events. */
+export declare class Gestures {
+    private readonly stage;
+    private readonly host;
+    private readonly pointers;
+    private readonly offs;
+    private mode;
+    private moved;
+    private start;
+    private startTime;
+    private startZoom;
+    private startMid;
+    private startDistance;
+    constructor(stage: HTMLElement, host: GestureHost);
+    destroy(): void;
+    /** Returns whether the last gesture moved, then clears the flag. */
+    consumeMoved(): boolean;
+    private onDown;
+    private onMove;
+    private onUp;
+    /** Anchors a new gesture on the currently pressed pointers. */
+    private begin;
+    private move;
+    /** Scales around the pinch midpoint so the content under the fingers stays put. */
+    private pinch;
+    private end;
+    /** Moves the whole stage with the finger and dims the backdrop on vertical drags. */
+    private dragStage;
+    private releaseStage;
+    /** A long or fast vertical swipe closes; a horizontal one navigates. */
+    private finishSwipe;
+}

package/dist/modules/hash.d.ts

@@ -0,0 +1,22 @@
+import type { Glare } from '../core/glare';
+/** Parses `#gallery-3` into `{ gallery: 'gallery', index: 2 }`. */
+export declare function parseHash(hash?: string): {
+    gallery: string;
+    index: number;
+} | null;
+/**
+ * Keeps the URL hash in sync with the current slide of a named gallery.
+ * Opening pushes one history entry so the browser's Back button closes the lightbox;
+ * slide changes replace it so Back never walks through every slide.
+ */
+export declare class Hash {
+    private readonly glare;
+    private readonly gallery;
+    private readonly off;
+    private pushed;
+    constructor(glare: Glare, gallery: string);
+    update(index?: number): void;
+    destroy(): void;
+    private onHashChange;
+    private replace;
+}

package/dist/modules/share.d.ts

@@ -0,0 +1,17 @@
+import type { ShareOptions } from '../types';
+import type { Glare } from '../core/glare';
+/** Overlay with social share links and a copyable URL. */
+export declare class Share {
+    private readonly glare;
+    private readonly container;
+    private readonly opts;
+    private overlay;
+    private off;
+    constructor(glare: Glare, container: HTMLElement, opts: ShareOptions);
+    get isOpen(): boolean;
+    open(): void;
+    close(): void;
+    destroy(): void;
+    private copy;
+    private resolveUrl;
+}

package/dist/modules/slideshow.d.ts

@@ -0,0 +1,25 @@
+import type { SlideshowOptions } from '../types';
+import type { Glare } from '../core/glare';
+/** Advances slides on a timer and animates the top progress bar. */
+export declare class Slideshow {
+    private readonly glare;
+    private readonly container;
+    private readonly opts;
+    private readonly bar;
+    private readonly button;
+    private timer;
+    private active;
+    constructor(glare: Glare, container: HTMLElement, opts: SlideshowOptions);
+    isActive(): boolean;
+    start(): void;
+    stop(): void;
+    toggle(): void;
+    onIndexChange(): void;
+    destroy(): void;
+    private get speed();
+    private get atEnd();
+    private schedule;
+    private clearTimer;
+    private setProgress;
+    private syncButton;
+}

package/dist/modules/thumbs.d.ts

@@ -0,0 +1,22 @@
+import type { ThumbsOptions } from '../types';
+import type { Glare } from '../core/glare';
+/** Clickable thumbnail strip, horizontal (`x`) or vertical (`y`). */
+export declare class Thumbs {
+    private readonly glare;
+    private readonly container;
+    private readonly opts;
+    isActive: boolean;
+    private readonly axis;
+    private readonly strip;
+    private readonly list;
+    private offs;
+    constructor(glare: Glare, container: HTMLElement, opts: ThumbsOptions);
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    /** Highlights the thumbnail for `index` and scrolls it into view. */
+    focus(index?: number): void;
+    destroy(): void;
+    private setActive;
+    private build;
+}

package/dist/modules/wheel.d.ts

@@ -0,0 +1,19 @@
+import type { SlideItem } from '../types';
+export interface WheelHost {
+    /** `'auto'` only navigates on image slides; `true` on every slide. */
+    mode: boolean | 'auto';
+    current(): SlideItem | null;
+    isZoomed(): boolean;
+    next(): void;
+    prev(): void;
+}
+/** Mouse-wheel navigation between slides: one gesture moves one slide. */
+export declare class WheelNav {
+    private readonly off;
+    private distance;
+    private fired;
+    private settle;
+    constructor(stage: HTMLElement, host: WheelHost);
+    destroy(): void;
+    private restartSettle;
+}

package/dist/templates.d.ts

@@ -0,0 +1,7 @@
+export declare const baseTemplate: string;
+export declare const buttonTemplates: Record<string, string>;
+export declare const spinnerTemplate = "<div class=\"glare-spinner\" role=\"status\" aria-label=\"{{LOADING}}\"></div>";
+export declare const errorTemplate = "<div class=\"glare-error\"><p>{{ERROR}}</p></div>";
+export declare const videoTemplate: string;
+export declare const iframeTemplate = "<iframe class=\"glare-iframe\"></iframe>";
+export declare const shareTemplate: string;

package/dist/types.d.ts

@@ -1,57 +1,58 @@
+import type { Point, Zoom } from './core/zoom';
+import type { Fullscreen } from './modules/fullscreen';
+import type { Share } from './modules/share';
+import type { Slideshow } from './modules/slideshow';
+import type { Thumbs } from './modules/thumbs';
 export type ContentType = 'image' | 'video' | 'iframe' | 'inline' | 'ajax' | 'html';
-export type AnimationEffect = false | 'fade' | 'zoom' | 'zoom-in-out' | 'slide' | 'circular' | 'tube' | 'rotate';
+/** Effect played when the lightbox opens. */
+export type AnimationEffect = false | 'fade' | 'zoom';
+/** Effect played when moving between slides. */
 export type TransitionEffect = false | 'fade' | 'slide' | 'circular' | 'tube' | 'zoom-in-out' | 'rotate';
-export type ClickAction = false | 'close' | 'next' | 'nextOrClose' | 'toggleControls' | 'zoom' | ((current: SlideItem, event: Event) => ClickAction | void);
-export type ToolbarButton = 'zoom' | 'slideshow' | 'thumbs' | 'close' | 'download' | 'share' | 'fullscreen' | string;
+export type ClickActionName = 'close' | 'next' | 'nextOrClose' | 'toggleControls' | 'zoom';
+export type ClickAction = false | ClickActionName | ((current: SlideItem, event: Event) => ClickActionName | false | void);
+export type ToolbarButton = 'zoom' | 'slideshow' | 'thumbs' | 'share' | 'download' | 'fullscreen' | 'close' | (string & {});
 export interface MediaProvider {
     matcher: RegExp;
-    type?: ContentType | 'iframe' | 'image';
+    type?: ContentType;
+    /** Embed URL; a string may reference capture groups as `$1`. */
     url?: string | ((match: RegExpMatchArray, url: string) => string);
     thumb?: string | ((match: RegExpMatchArray, url: string) => string);
     params?: Record<string, string | number | boolean>;
-    paramPlace?: number;
 }
+/** A slide as provided by the user. */
 export interface SlideSource {
     src?: string;
     type?: ContentType;
-    width?: number | string;
-    height?: number | string;
     caption?: string;
+    /** Fallback for `caption`. */
     title?: string;
-    thumb?: string;
     alt?: string;
-    downloadSrc?: string;
-    html?: string;
-    content?: string | HTMLElement;
+    thumb?: string;
+    width?: number | string;
+    height?: number | string;
     poster?: string;
     format?: string;
-    preload?: boolean;
     autoStart?: boolean;
-    opts?: Partial<GlareOptions>;
+    downloadSrc?: string;
+    html?: string;
+    content?: string | HTMLElement;
     $trigger?: HTMLElement | null;
-    [key: string]: unknown;
 }
+/** A normalized slide with runtime state. */
 export interface SlideItem extends SlideSource {
     index: number;
-    type: ContentType;
     src: string;
-    contentEl?: HTMLElement | null;
-    $content?: HTMLElement | null;
-    $slide?: HTMLElement | null;
-    $image?: HTMLImageElement | null;
-    isLoaded?: boolean;
-    isComplete?: boolean;
-    isError?: boolean;
-    hasError?: boolean;
-    pos?: number;
-    width?: number | string;
-    height?: number | string;
+    type: ContentType;
+    caption: string;
+    isLoaded: boolean;
+    hasError: boolean;
+    /** The reason the content failed to load, when `hasError` is set. */
+    error?: unknown;
     contentWidth?: number;
     contentHeight?: number;
-    scaleX?: number;
-    scaleY?: number;
-    canZoomIn?: boolean;
-    canZoomOut?: boolean;
+    $slide?: HTMLElement | null;
+    $content?: HTMLElement | null;
+    $image?: HTMLImageElement | null;
 }
 export interface TouchOptions {
     vertical?: boolean;
@@ -61,9 +62,7 @@ export interface ImageOptions {
     preload?: boolean;
 }
 export interface AjaxOptions {
-    settings?: RequestInit & {
-        data?: Record<string, string>;
-    };
+    settings?: RequestInit;
 }
 export interface IframeOptions {
     preload?: boolean;
@@ -78,7 +77,6 @@ export interface VideoOptions {
 }
 export interface ThumbsOptions {
     autoStart?: boolean;
-    hideOnClose?: boolean;
     parentEl?: string | HTMLElement;
     axis?: 'x' | 'y';
 }
@@ -93,145 +91,133 @@ export interface ShareOptions {
     url?: string | ((item: SlideItem) => string);
     tpl?: string;
 }
-export interface HashOptions {
-    enabled?: boolean;
-}
-export interface I18nDict {
+export type I18nDict = {
     CLOSE: string;
     NEXT: string;
     PREV: string;
     ERROR: string;
+    LOADING: string;
+    LIGHTBOX: string;
+    GO_TO_SLIDE: string;
+    VIDEO_UNSUPPORTED: string;
     PLAY_START: string;
     PLAY_STOP: string;
     FULL_SCREEN: string;
+    FULL_SCREEN_EXIT: string;
     THUMBS: string;
     DOWNLOAD: string;
     SHARE: string;
+    COPY: string;
     ZOOM: string;
-}
-export type EventName = 'onInit' | 'beforeLoad' | 'afterLoad' | 'beforeShow' | 'afterShow' | 'beforeClose' | 'afterClose' | 'onActivate' | 'onDeactivate' | 'onUpdate' | 'onReveal' | 'onDestroy';
-export type EventHandler = (instance: GlareInstance, current?: SlideItem, ...args: unknown[]) => unknown;
-export interface GlareOptions {
+    ZOOM_OUT: string;
+};
+/** Events that concern the instance as a whole. */
+export type LifecycleEvent = 'onInit' | 'onActivate';
+/** Events that concern one slide; the handler always receives it. */
+export type SlideEvent = 'beforeLoad' | 'afterLoad' | 'onError' | 'beforeShow' | 'afterShow' | 'onUpdate' | 'beforeClose' | 'afterClose';
+export type EventName = LifecycleEvent | SlideEvent;
+export type LifecycleHandler = (instance: GlareInstance) => unknown;
+export type EventHandler = (instance: GlareInstance, current: SlideItem) => unknown;
+export type EventHandlers = Partial<Record<LifecycleEvent, LifecycleHandler> & Record<SlideEvent, EventHandler>>;
+export interface GlareOptions extends EventHandlers {
     closeExisting?: boolean;
     loop?: boolean;
-    gutter?: number;
     keyboard?: boolean;
-    preventCaptionOverlap?: boolean;
+    protect?: boolean;
+    modal?: boolean;
+    idleTime?: number | false;
+    hideScrollbar?: boolean;
+    autoFocus?: boolean;
+    backFocus?: boolean;
+    trapFocus?: boolean;
+    defaultType?: ContentType;
+    parentEl?: string | HTMLElement;
+    baseClass?: string;
+    slideClass?: string;
     arrows?: boolean;
     infobar?: boolean;
-    smallBtn?: boolean | 'auto';
     toolbar?: boolean | 'auto';
+    smallBtn?: boolean | 'auto';
     buttons?: ToolbarButton[];
-    idleTime?: number | false;
-    protect?: boolean;
-    modal?: boolean;
-    image?: ImageOptions;
-    ajax?: AjaxOptions;
-    iframe?: IframeOptions;
-    video?: VideoOptions;
-    defaultType?: ContentType;
+    caption?: string | ((instance: GlareInstance, current: SlideItem) => string);
     animationEffect?: AnimationEffect;
     animationDuration?: number;
-    zoomOpacity?: boolean | 'auto';
+    zoomOpacity?: boolean;
     transitionEffect?: TransitionEffect;
     transitionDuration?: number;
-    slideClass?: string;
-    baseClass?: string;
-    parentEl?: string | HTMLElement;
-    hideScrollbar?: boolean;
-    autoFocus?: boolean;
-    backFocus?: boolean;
-    trapFocus?: boolean;
-    fullScreen?: FullscreenOptions | boolean;
-    touch?: TouchOptions | false;
-    hash?: HashOptions | boolean | null;
-    media?: Record<string, MediaProvider>;
-    slideShow?: SlideshowOptions | boolean;
-    thumbs?: ThumbsOptions | boolean;
-    share?: ShareOptions | boolean;
-    wheel?: boolean | 'auto' | 'slide';
     clickContent?: ClickAction;
     clickSlide?: ClickAction;
-    clickOutside?: ClickAction;
     dblclickContent?: ClickAction;
     dblclickSlide?: ClickAction;
-    dblclickOutside?: ClickAction;
+    wheel?: boolean | 'auto';
+    touch?: TouchOptions | false;
+    /** Overrides applied on touch-first devices. */
     mobile?: Partial<GlareOptions>;
+    image?: ImageOptions;
+    video?: VideoOptions;
+    iframe?: IframeOptions;
+    ajax?: AjaxOptions;
+    media?: Record<string, MediaProvider>;
+    hash?: boolean;
+    slideshow?: SlideshowOptions | boolean;
+    thumbs?: ThumbsOptions | boolean;
+    fullscreen?: FullscreenOptions | boolean;
+    share?: ShareOptions | boolean;
     lang?: string;
     i18n?: Record<string, Partial<I18nDict>>;
-    caption?: string | ((instance: GlareInstance, current: SlideItem) => string);
-    onInit?: EventHandler;
-    beforeLoad?: EventHandler;
-    afterLoad?: EventHandler;
-    beforeShow?: EventHandler;
-    afterShow?: EventHandler;
-    beforeClose?: EventHandler;
-    afterClose?: EventHandler;
-    onActivate?: EventHandler;
-    onDeactivate?: EventHandler;
-    onUpdate?: EventHandler;
+    baseTpl?: string;
     btnTpl?: Partial<Record<string, string>>;
     spinnerTpl?: string;
     errorTpl?: string;
-    baseTpl?: string;
-    [key: string]: unknown;
+}
+type DefaultedKey = Exclude<keyof GlareOptions, keyof EventHandlers | 'caption'>;
+/** Options after the defaults have been merged in: everything but callbacks is present. */
+export type ResolvedOptions = GlareOptions & Required<Pick<GlareOptions, DefaultedKey>> & {
+    image: Required<ImageOptions>;
+    video: Required<VideoOptions>;
+    iframe: Required<IframeOptions>;
+    ajax: Required<AjaxOptions>;
+};
+/** Elements of the mounted dialog. `container` and `stage` are required by the base template; the rest are optional chrome. */
+export interface GlareRefs {
+    container: HTMLElement;
+    bg: HTMLElement | null;
+    inner: HTMLElement | null;
+    stage: HTMLElement;
+    caption: HTMLElement | null;
+    toolbar: HTMLElement | null;
+    infobar: HTMLElement | null;
+    navigation: HTMLElement | null;
 }
 export interface GlareInstance {
-    id: number;
-    group: SlideItem[];
-    opts: GlareOptions;
+    readonly id: number;
+    readonly group: SlideItem[];
+    readonly opts: GlareOptions;
+    readonly zoom: Zoom;
     current: SlideItem | null;
     currIndex: number;
     prevIndex: number;
     isActive: boolean;
     isClosing: boolean;
-    isAnimating: boolean;
-    $refs: {
-        container: HTMLElement | null;
-        stage: HTMLElement | null;
-        bg: HTMLElement | null;
-        inner: HTMLElement | null;
-        caption: HTMLElement | null;
-        toolbar: HTMLElement | null;
-        infobar: HTMLElement | null;
-        navigation: HTMLElement | null;
-    };
-    open: (index?: number) => void;
-    close: (event?: Event | null, duration?: number) => void;
-    next: (duration?: number) => void;
-    previous: (duration?: number) => void;
-    prev: (duration?: number) => void;
-    jumpTo: (index: number, duration?: number) => void;
-    scaleToFit: (duration?: number) => void;
-    scaleToActual: (x?: number, y?: number, duration?: number) => void;
-    update: () => void;
-    focus: () => void;
-    toggleControls: (force?: boolean) => void;
     isIdle: boolean;
-    SlideShow?: {
-        start: () => void;
-        stop: () => void;
-        toggle: () => void;
-        isActive: () => boolean;
-    };
-    Thumbs?: {
-        show: () => void;
-        hide: () => void;
-        toggle: () => void;
-        focus: (index?: number) => void;
-        isActive: boolean;
-    };
-    FullScreen?: {
-        request: () => void;
-        exit: () => void;
-        toggle: () => void;
-        isFullscreen: () => boolean;
-    };
+    /** Null while the lightbox is closed. */
+    $refs: GlareRefs | null;
+    slideshow?: Slideshow;
+    thumbs?: Thumbs;
+    fullscreen?: Fullscreen;
+    share?: Share;
+    open(index?: number): void;
+    close(): void;
+    next(): void;
+    prev(): void;
+    jumpTo(index: number): void;
+    toggleZoom(focus?: Point): void;
+    update(): void;
+    focus(): void;
+    toggleControls(force?: boolean): void;
 }
 export interface BoundGroup {
-    selector: string;
-    options: GlareOptions;
     elements: HTMLElement[];
     destroy: () => void;
 }
-//# sourceMappingURL=types.d.ts.map
+export {};

package/dist/umd.d.ts

@@ -0,0 +1,3 @@
+import './styles/index.css';
+import { Glare } from './core/glare';
+export default Glare;

package/dist/utils/dom.d.ts

@@ -0,0 +1,20 @@
+export declare function $(selector: string, root?: ParentNode): HTMLElement | null;
+export declare function $$(selector: string, root?: ParentNode): HTMLElement[];
+export declare function createEl<K extends keyof HTMLElementTagNameMap>(tag: K, className?: string, html?: string): HTMLElementTagNameMap[K];
+/** Parses an HTML string and returns its first element. */
+export declare function fromHtml(html: string): HTMLElement;
+/** Strips markup from an HTML string, for labels that must be plain text. */
+export declare function toText(html: string): string;
+/** Resolves a selector or element, searching `root` first and then the document. */
+export declare function resolveElement(target: string | HTMLElement | null | undefined, root?: ParentNode): HTMLElement | null;
+export declare function toCssSize(value: number | string): string;
+/** Adds an event listener and returns a function that removes it. */
+export declare function on<K extends keyof GlobalEventHandlersEventMap>(target: EventTarget, type: K, handler: (event: GlobalEventHandlersEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+export declare function on(target: EventTarget, type: string, handler: EventListener, options?: boolean | AddEventListenerOptions): () => void;
+/** Runs `callback` after the browser has painted the current frame. */
+export declare function nextFrame(callback: () => void): void;
+/**
+ * Runs `done` exactly once when a transition on `el` ends,
+ * or after `duration` as a fallback for transitions that never fire.
+ */
+export declare function afterTransition(el: HTMLElement, duration: number, done: () => void): void;

package/dist/utils/env.d.ts

@@ -0,0 +1,5 @@
+export declare function isMobile(): boolean;
+export declare function prefersReducedMotion(): boolean;
+export declare function supportsFullscreen(): boolean;
+/** Locks page scrolling while compensating for the scrollbar width. */
+export declare function lockScroll(lock: boolean): void;

package/dist/utils/object.d.ts

@@ -0,0 +1,3 @@
+/** Recursively merges plain objects; other values (arrays, elements, RegExps) are replaced. */
+export declare function deepMerge<T extends object>(...sources: Array<object | null | undefined | false>): T;
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/utils/template.d.ts

@@ -0,0 +1,5 @@
+/** Replaces `{{key}}` placeholders with values from `dict`. */
+export declare function translate(template: string, dict: Record<string, string>): string;
+export declare function buildQuery(params: Record<string, string | number | boolean>): string;
+/** Expands `$1`-style capture references from a RegExp match. */
+export declare function expandMatch(template: string, match: RegExpMatchArray): string;