@leavepulse/ui 0.81.0 → 0.83.0

package/dist/components/LpWindow.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpWindow-DJxE8Zl-.js";
+import { _ as _sfc_main } from "../chunks/LpWindow-YnF_knSj.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpWorkspaceSwitcher.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpWorkspaceSwitcher-Bpf41Bw5.js";
+import { _ as _sfc_main } from "../chunks/LpWorkspaceSwitcher-B-5UU6o4.js";
 export {
   _sfc_main as default
 };

package/dist/components/MenuTitle.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/MenuTitle-CMjvLsvC.js";
+import { _ as _sfc_main } from "../chunks/MenuTitle-BnZbFSwq.js";
 export {
   _sfc_main as default
 };

package/dist/components/OptionContent.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/OptionContent-DY8NaG8s.js";
+import { _ as _sfc_main } from "../chunks/OptionContent-D5e_eklA.js";
 export {
   _sfc_main as default
 };

package/dist/components/PickerField.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/PickerField-CgfkaBgg.js";
+import { _ as _sfc_main } from "../chunks/PickerField-KpHiowNI.js";
 export {
   _sfc_main as default
 };

package/dist/components/RevealToggle.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/RevealToggle-CPMXxaKv.js";
+import { _ as _sfc_main } from "../chunks/RevealToggle-CE1hAIJB.js";
 export {
   _sfc_main as default
 };

package/dist/components/SteadyText.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    text: string;
+    widest: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/SteadyText.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/SteadyText-CwH-kduj.js";
+export {
+  _sfc_main as default
+};

package/dist/components/TourCard.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/TourCard-D4b3lMHi.js";
+import { _ as _sfc_main } from "../chunks/TourCard-t2csiTDS.js";
 export {
   _sfc_main as default
 };

package/dist/components/VideoFlash.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    /** What happened, and a count that changes on every press so the same icon twice still plays twice. */
+    flash: {
+        icon: string;
+        n: number;
+    } | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VideoFlash.vue.js

@@ -0,0 +1,33 @@
+import { defineComponent, openBlock, createElementBlock, createVNode, normalizeClass, createCommentVNode } from "vue";
+import { _ as _sfc_main$1 } from "../chunks/LpIcon-CoOLz1oJ.js";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
+import '../assets/VideoFlash-VuPkC7QV.css';const _hoisted_1 = {
+  class: "pointer-events-none absolute inset-0 flex items-center justify-center motion-reduce:hidden",
+  "aria-hidden": "true"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "VideoFlash",
+  props: {
+    flash: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.flash ? (openBlock(), createElementBlock("span", {
+          key: __props.flash.n,
+          class: "lp-video-flash flex size-16 items-center justify-center rounded-full bg-black/50 text-white opacity-0"
+        }, [
+          createVNode(_sfc_main$1, {
+            name: __props.flash.icon,
+            size: 28,
+            class: normalizeClass(__props.flash.icon === "lucide:play" ? "translate-x-0.5" : "")
+          }, null, 8, ["name", "class"])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const VideoFlash = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-5cab097a"]]);
+export {
+  VideoFlash as default
+};

package/dist/components/VideoThumb.vue.d.ts

@@ -0,0 +1,12 @@
+import type { LightboxItem } from "./lightbox";
+type __VLS_Props = {
+    item: LightboxItem;
+    /** Classes for the picture itself (the gallery's blur and dimming ride on it). */
+    mediaClass?: string | (string | false | undefined)[];
+    /** A small thumbnail: the badge shrinks and the length is left out. */
+    compact?: boolean;
+    alt?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VideoThumb.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/VideoThumb-Csf9bUz3.js";
+export {
+  _sfc_main as default
+};

package/dist/components/VideoVolume.vue.d.ts

@@ -0,0 +1,15 @@
+import type { VideoMedia } from "../composables/useVideoMedia";
+type __VLS_Props = {
+    media: VideoMedia;
+    labels: {
+        mute: string;
+        unmute: string;
+        volume: string;
+    };
+    disabled?: boolean;
+    /** Over the picture (white on the video) rather than on the page. */
+    overlay?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VideoVolume.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/VideoVolume-B4_DNmNi.js";
+export {
+  _sfc_main as default
+};

package/dist/components/chartWindow.js

@@ -1,4 +1,5 @@
 import { clamp } from "../composables/clamp.js";
+import { shiftSpan, zoomSpan } from "../composables/span.js";
 const MIN_RANGE_POINTS = 2;
 const SLOTS_PER_BUCKET = 2;
 const LTTB_MIN_TARGET = 3;
@@ -16,16 +17,11 @@ function clampRange(range, count) {
 }
 function zoomRange(range, count, anchor, factor) {
   const from = range ?? { start: 0, end: count - 1 };
-  const span = from.end - from.start;
-  const next = Math.max(MIN_RANGE_POINTS - 1, span * factor);
-  const at = from.start + span * clamp(anchor, 0, 1);
-  const start = at - (at - from.start) * (next / (span || 1));
-  return clampRange({ start, end: start + next }, count);
+  const at = from.start + (from.end - from.start) * clamp(anchor, 0, 1);
+  return clampRange(zoomSpan(from.start, from.end, at, factor, MIN_RANGE_POINTS - 1), count);
 }
 function panRange(range, count, delta) {
-  const span = range.end - range.start;
-  const start = Math.max(0, Math.min(count - 1 - span, range.start + delta));
-  return clampRange({ start, end: start + span }, count);
+  return clampRange(shiftSpan(range.start, range.end, delta, 0, count - 1), count);
 }
 function minMaxBuckets(series, slots) {
   const count = series.reduce((n, values2) => Math.max(n, values2.length), 0);

package/dist/components/lightbox.d.ts

@@ -19,6 +19,19 @@ export interface LightboxItem {
      * a marked picture sitting beside plain ones.
      */
     spoiler?: boolean;
+    /**
+     * A video rather than a picture: shown in LpVideoPlayer, with a play badge
+     * on its tile and its strip thumbnail. Left out, an address ending in a
+     * video extension (.mp4, .webm, .mov…) counts as one; set it for an address
+     * that does not say (an API route, a blob: URL).
+     */
+    kind?: "image" | "video";
+    /** A still for a video's tile and thumbnail; the video's first frame when absent. */
+    poster?: string;
+    /** A video's length in seconds, for the badge on its tile, when known up front. */
+    duration?: number;
 }
+/** Whether the item is a video: said outright by `kind`, else told by its address's extension. */
+export declare function isVideoItem(item: Pick<LightboxItem, "src" | "kind">): boolean;
 /** Last path segment of a URL, or a fallback — used to name a download. */
 export declare function fileNameOf(item: LightboxItem, fallback?: string): string;

package/dist/components/lightbox.js

@@ -1,3 +1,12 @@
+const VIDEO_EXTENSION = /\.(mp4|m4v|webm|mov|ogv|ogg|mkv)$/i;
+function isVideoItem(item) {
+  if (item.kind) return item.kind === "video";
+  try {
+    return VIDEO_EXTENSION.test(new URL(item.src, "http://x").pathname);
+  } catch {
+    return false;
+  }
+}
 function fileNameOf(item, fallback = "image") {
   if (item.filename) return item.filename;
   try {
@@ -9,5 +18,6 @@ function fileNameOf(item, fallback = "image") {
   return fallback;
 }
 export {
-  fileNameOf
+  fileNameOf,
+  isVideoItem
 };

package/dist/components/menuWhen.js

@@ -1,5 +1,5 @@
 import { defineComponent, h } from "vue";
-import { _ as _sfc_main } from "../chunks/LpContextMenu-bn5bc9t7.js";
+import { _ as _sfc_main } from "../chunks/LpContextMenu-DIYhlap8.js";
 const MenuWhen = defineComponent({
   name: "MenuWhen",
   inheritAttrs: false,

package/dist/components/videoBackdrop.d.ts

@@ -33,5 +33,18 @@ export declare function seamReached(plan: LoopPlan, time: number): boolean;
 export declare function seamProgress(plan: LoopPlan, incomingTime: number): number;
 /** Whether the whole clip loops with nothing cut and no overlap, which the media element does natively. */
 export declare function isNativeLoop(plan: LoopPlan, duration: number): boolean;
-/** "1:05", "0:07.5": a position on a clip as a range slider labels it. */
-export declare function formatClipTime(seconds: number, precise?: boolean): string;
+/**
+ * "1:05", "0:07.5": a position on a clip as a range slider labels it.
+ * `precise` adds tenths when there are any; "fixed" always writes them, for a
+ * time that changes while it is read, so it keeps one length ("0:05.0", not
+ * "0:05" between "0:04.9" and "0:05.1").
+ */
+export declare function formatClipTime(seconds: number, precise?: boolean | "fixed"): string;
+/** The widest a clip time up to `seconds` gets, its digits as zeros: what SteadyText reserves. */
+export declare function widestClipTime(seconds: number): string;
+/**
+ * The slowest rate a pause eases down to before the element is paused, and a
+ * start eases up from. Chromium refuses a rate below a sixteenth; past that
+ * point the picture is all but still anyway.
+ */
+export declare const SLOWEST_RATE: number;

package/dist/components/videoBackdrop.js

@@ -29,12 +29,18 @@ function formatClipTime(seconds, precise = false) {
   const minutes = (t.days * 24 + t.hours) * 60 + t.minutes;
   const secs = String(t.seconds).padStart(2, "0");
   const tenth = Math.floor(t.ms / 100);
-  return precise && tenth ? `${minutes}:${secs}.${tenth}` : `${minutes}:${secs}`;
+  return precise === "fixed" || precise && tenth ? `${minutes}:${secs}.${tenth}` : `${minutes}:${secs}`;
 }
+function widestClipTime(seconds) {
+  return formatClipTime(seconds, "fixed").replace(/\d/g, "0");
+}
+const SLOWEST_RATE = 1 / 16;
 export {
+  SLOWEST_RATE,
   formatClipTime,
   isNativeLoop,
   planLoop,
   seamProgress,
-  seamReached
+  seamReached,
+  widestClipTime
 };

package/dist/components/videoFrames.d.ts

@@ -0,0 +1,37 @@
+export interface FrameRequest {
+    key: string;
+    time: number;
+}
+type VideoWithFrames = HTMLVideoElement & {
+    requestVideoFrameCallback?: (cb: () => void) => number;
+    fastSeek?: (time: number) => void;
+};
+export declare class FrameSampler {
+    private readonly video;
+    private readonly size;
+    private readonly onFrame;
+    private queue;
+    private running;
+    private disposed;
+    private cache;
+    constructor(video: VideoWithFrames, size: () => {
+        width: number;
+        height: number;
+    }, onFrame: (key: string, canvas: HTMLCanvasElement) => void);
+    /** A frame taken earlier, if it is still kept. */
+    cached(key: string): HTMLCanvasElement | undefined;
+    /** The frames wanted now, most wanted first; whatever was queued before is dropped. */
+    want(requests: FrameRequest[]): void;
+    dispose(): void;
+    private pump;
+    private take;
+    private framePresented;
+    private once;
+}
+/**
+ * Seconds one still stands for at this zoom: the shortest power of two that
+ * keeps a still at least `minPx` wide. Stills sit at fixed points in time, so
+ * panning reuses the ones already taken and a zoom step of two keeps half.
+ */
+export declare function stillSpan(secondsPerPx: number, minPx: number): number;
+export {};

package/dist/components/videoFrames.js

@@ -0,0 +1,134 @@
+const SEEK_TIMEOUT_MS = 4e3;
+const FRAME_TIMEOUT_MS = 250;
+const CACHE_LIMIT = 240;
+class FrameSampler {
+  constructor(video, size, onFrame) {
+    this.video = video;
+    this.size = size;
+    this.onFrame = onFrame;
+  }
+  video;
+  size;
+  onFrame;
+  queue = [];
+  running = false;
+  disposed = false;
+  cache = /* @__PURE__ */ new Map();
+  /** A frame taken earlier, if it is still kept. */
+  cached(key) {
+    const hit = this.cache.get(key);
+    if (hit) {
+      this.cache.delete(key);
+      this.cache.set(key, hit);
+    }
+    return hit;
+  }
+  /** The frames wanted now, most wanted first; whatever was queued before is dropped. */
+  want(requests) {
+    this.queue = requests.filter((r) => !this.cache.has(r.key));
+    void this.pump();
+  }
+  dispose() {
+    this.disposed = true;
+    this.queue = [];
+    this.cache.clear();
+  }
+  async pump() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      while (!this.disposed && this.queue.length) {
+        const next = this.queue.shift();
+        if (this.cache.has(next.key)) continue;
+        const canvas = await this.take(next.time);
+        if (this.disposed) return;
+        if (!canvas) continue;
+        this.cache.set(next.key, canvas);
+        if (this.cache.size > CACHE_LIMIT) this.cache.delete(this.cache.keys().next().value);
+        this.onFrame(next.key, canvas);
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+  async take(time) {
+    const video = this.video;
+    if (video.readyState < 1) {
+      const ready = await this.once("loadedmetadata", SEEK_TIMEOUT_MS);
+      if (!ready) return null;
+    }
+    const target = Math.min(Math.max(0, time), Number.isFinite(video.duration) ? Math.max(0, video.duration - 0.05) : time);
+    const seeked = this.once("seeked", SEEK_TIMEOUT_MS);
+    if (video.fastSeek) video.fastSeek(target);
+    else video.currentTime = target;
+    if (!await seeked) return null;
+    await this.framePresented();
+    if (this.disposed || !video.videoWidth) return null;
+    const { width, height } = this.size();
+    const ratio = Math.min(2, video.ownerDocument.defaultView?.devicePixelRatio ?? 1);
+    const canvas = video.ownerDocument.createElement("canvas");
+    canvas.width = Math.max(1, Math.round(width * ratio));
+    canvas.height = Math.max(1, Math.round(height * ratio));
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    const scale = Math.max(canvas.width / video.videoWidth, canvas.height / video.videoHeight);
+    const w = video.videoWidth * scale;
+    const h = video.videoHeight * scale;
+    try {
+      ctx.drawImage(video, (canvas.width - w) / 2, (canvas.height - h) / 2, w, h);
+    } catch {
+      return null;
+    }
+    return canvas;
+  }
+  /*
+   * `seeked` says the position moved, not that its picture is ready to draw:
+   * Chromium can still hand the previous frame for a moment. Wait for the
+   * frame where the engine reports it, and a couple of paints where not.
+   */
+  framePresented() {
+    const video = this.video;
+    const win = video.ownerDocument.defaultView;
+    return new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        resolve();
+      };
+      if (video.requestVideoFrameCallback) {
+        video.requestVideoFrameCallback(finish);
+        win?.setTimeout(finish, FRAME_TIMEOUT_MS);
+      } else if (win) {
+        win.requestAnimationFrame(() => win.requestAnimationFrame(finish));
+      } else finish();
+    });
+  }
+  once(event, timeout) {
+    const video = this.video;
+    const win = video.ownerDocument.defaultView;
+    return new Promise((resolve) => {
+      const finish = (ok) => {
+        video.removeEventListener(event, onEvent);
+        video.removeEventListener("error", onError);
+        if (timer) win?.clearTimeout(timer);
+        resolve(ok);
+      };
+      const onEvent = () => finish(true);
+      const onError = () => finish(false);
+      video.addEventListener(event, onEvent);
+      video.addEventListener("error", onError);
+      const timer = win?.setTimeout(() => finish(false), timeout);
+    });
+  }
+}
+function stillSpan(secondsPerPx, minPx) {
+  const wanted = secondsPerPx * minPx;
+  let span = 1 / 8;
+  while (span < wanted && span < 8192) span *= 2;
+  return span;
+}
+export {
+  FrameSampler,
+  stillSpan
+};

package/dist/components/videoMotion.d.ts

@@ -0,0 +1,28 @@
+export declare const FADE: {
+    readonly enterActiveClass: "transition-opacity duration-(--duration-medium) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly leaveActiveClass: "transition-opacity duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly enterFromClass: "opacity-0";
+    readonly leaveToClass: "opacity-0";
+};
+/** A fade with a small settle in scale: for a button or a box, which reads as arriving rather than blinking on. */
+export declare const FADE_SCALE: {
+    readonly enterActiveClass: "transition-[opacity,scale] duration-(--duration-medium) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly leaveActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly enterFromClass: "scale-90 opacity-0";
+    readonly leaveToClass: "scale-90 opacity-0";
+};
+/** One icon handing over to another in the same spot (play and pause, sound on and off). */
+export declare const ICON_SWAP: {
+    readonly mode: "out-in";
+    readonly enterActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly leaveActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none";
+    readonly enterFromClass: "scale-75 opacity-0";
+    readonly leaveToClass: "scale-75 opacity-0";
+};
+/**
+ * A ghost button over the picture: white on the video in every theme, as the
+ * lightbox's are. The players' own buttons use it, and their `#actions` and
+ * `#controls` slots hand it out as `buttonClass`, so an app's button there
+ * (a bin that takes the video back out of a dropzone) looks like theirs.
+ */
+export declare const OVERLAY_BUTTON = "text-white/85 hover:bg-white/15 hover:text-white";

package/dist/components/videoMotion.js

@@ -0,0 +1,26 @@
+const FADE = {
+  enterActiveClass: "transition-opacity duration-(--duration-medium) ease-(--ease-emphasized) motion-reduce:transition-none",
+  leaveActiveClass: "transition-opacity duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none",
+  enterFromClass: "opacity-0",
+  leaveToClass: "opacity-0"
+};
+const FADE_SCALE = {
+  enterActiveClass: "transition-[opacity,scale] duration-(--duration-medium) ease-(--ease-emphasized) motion-reduce:transition-none",
+  leaveActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none",
+  enterFromClass: "scale-90 opacity-0",
+  leaveToClass: "scale-90 opacity-0"
+};
+const ICON_SWAP = {
+  mode: "out-in",
+  enterActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none",
+  leaveActiveClass: "transition-[opacity,scale] duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none",
+  enterFromClass: "scale-75 opacity-0",
+  leaveToClass: "scale-75 opacity-0"
+};
+const OVERLAY_BUTTON = "text-white/85 hover:bg-white/15 hover:text-white";
+export {
+  FADE,
+  FADE_SCALE,
+  ICON_SWAP,
+  OVERLAY_BUTTON
+};

package/dist/components/videoTrim.d.ts

@@ -0,0 +1,68 @@
+export type TimeRange = [number, number];
+/** A rectangle on the video's frame, every value a fraction of it (0..1). */
+export interface FrameRegion {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface RangeLimits {
+    duration: number;
+    /** Shortest clip, seconds. */
+    minClip: number;
+    /** Longest clip, seconds; Infinity for none. */
+    maxClip: number;
+}
+/**
+ * A typed time, the inverse of `formatClipTime`: "75", "75.5", "1:15",
+ * "75:00.5", and "1:02:03.25" for whoever types the hours. A comma reads as
+ * the decimal point, as a Russian keyboard's numpad types it. Anything else,
+ * a negative or a seconds field past 59 after a colon, is null.
+ */
+export declare function parseClipTime(text: string): number | null;
+/** A range that keeps every limit: inside the video, no shorter than minClip, no longer than maxClip. */
+export declare function normalizeRange(range: TimeRange | null | undefined, limits: RangeLimits): TimeRange;
+/**
+ * One end dragged to `t`. The dragged end stops at a limit and the other end
+ * stays put: a handle that pushed its partner would move the clip's other
+ * edge without the person touching it.
+ */
+export declare function dragEnd(range: TimeRange, end: 0 | 1, t: number, limits: RangeLimits): TimeRange;
+/**
+ * One end set to `t` on purpose (the I or O key, a typed time). That end goes
+ * where it was told, and the other follows when a limit asks for it.
+ */
+export declare function setEnd(range: TimeRange, end: 0 | 1, t: number, limits: RangeLimits): TimeRange;
+export interface TimeView {
+    start: number;
+    end: number;
+}
+/** The view zoomed by `factor` (above 1 zooms in) around `anchor`, which stays where it is on screen. */
+export declare function zoomView(view: TimeView, anchor: number, factor: number, duration: number, minSpan: number): TimeView;
+/** The view moved by `delta` seconds, held inside the video. */
+export declare function shiftView(view: TimeView, delta: number, duration: number): TimeView;
+/** The view moved just enough to show `t`, with `margin` of its span to spare. */
+export declare function revealTime(view: TimeView, t: number, duration: number, margin?: number): TimeView;
+/** Seconds between ruler marks, so that marks stand at least `minPx` apart. */
+export declare function tickStep(span: number, width: number, minPx?: number): number;
+/** The ruler's marks within the view. */
+export declare function ticks(view: TimeView, step: number): number[];
+/**
+ * Where the picture sits in a box that shows it whole (object-fit: contain):
+ * the region is drawn on the picture, not on the black bars around it.
+ */
+export declare function containRect(boxWidth: number, boxHeight: number, videoWidth: number, videoHeight: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** A region held inside the frame and no smaller than `minSize` a side. */
+export declare function clampRegion(r: FrameRegion, minSize?: number): FrameRegion;
+/** The region spanned by two corners, in either order, cut to the frame. */
+export declare function regionBetween(ax: number, ay: number, bx: number, by: number): FrameRegion;
+export type RegionHandle = "move" | "nw" | "ne" | "sw" | "se";
+/** The region after one of its handles moved by (dx, dy), fractions of the frame. */
+export declare function adjustRegion(r: FrameRegion, handle: RegionHandle, dx: number, dy: number, minSize?: number): FrameRegion;
+/** Why the editor has no video to show; see `VideoErrorCause`. */
+export type { VideoErrorCause as VideoTrimErrorCause } from "../composables/useVideoMedia";