allyhub 0.4.0 → 0.6.0

package/dist/node_modules/@allyhub-next/video-core/dist/measure.d.ts

@@ -0,0 +1,558 @@
+import type { SafeZone } from "./formats.js";
+import type { Box } from "./problem.js";
+import type { PixelRect, TimelineFootage } from "./timeline.js";
+/** A block of text on screen at a moment: one layer's line or paragraph. */
+export interface MeasuredText {
+    /** The layer's component name ("custom" for custom()). */
+    layer: string;
+    /** The plane it is drawn in. */
+    z: "front" | "behind-person" | "overlay";
+    text: string;
+    /** Its box in the frame's pixels, rounded. */
+    box: Box;
+    /** Inside a page viewport (a site demo): the page's own text. */
+    viewport?: true;
+    /**
+     * How opaque it is drawn, the lowest of its text nodes' (each the product
+     * of its element's and its ancestors'), when under 1.
+     */
+    opacity?: number;
+    /**
+     * The box of what shows of its glyphs, when not `box`: the rows they
+     * cover (a line's box is the font's whole ascent and descent, taller
+     * than what is drawn), cut where an ancestor clips its content. Blocks of
+     * one layer, and a block and the boxes it is drawn inside, are compared
+     * by it.
+     */
+    ink?: Box;
+    /**
+     * The font families its characters are drawn in, in the order they first
+     * draw one: by the faces the page declares and their ranges, as the
+     * browser picks them (the runtime's drawnFamilies).
+     */
+    fonts?: string[];
+}
+/** What makes an element a box one can see: a background, a border, a shadow. */
+export type BoxPaint = "background" | "border" | "shadow";
+/**
+ * A box a text block is drawn inside: an element between the block and its
+ * layer with a background, a border or a shadow (the block's own element
+ * too), nearest first.
+ */
+export interface TextContainer {
+    /** In the frame's pixels, rounded. */
+    box: Box;
+    paint: BoxPaint[];
+}
+/** A text block reaching outside a box it is drawn inside. */
+export interface TextOutside {
+    text: number;
+    /** The nearest box it reaches out of. */
+    container: TextContainer;
+    /** Per edge of that box it crosses: pixels past the edge. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+}
+/** Two text blocks drawn over each other. */
+export interface TextOverlap {
+    /** Indices into the moment's texts. */
+    a: number;
+    b: number;
+    /** Pixels both cover. */
+    area: number;
+    /** That area as a share of the smaller block's box (0–1). */
+    share: number;
+}
+/** A text block over the speaker's face. */
+export interface FaceOverlap {
+    text: number;
+    area: number;
+    /** Share of the text block's box. */
+    ofText: number;
+    /** Share of the face's box. */
+    ofFace: number;
+}
+/** A text block reaching into the area a platform's interface covers (not a page viewport's own text). */
+export interface SafeOverlap {
+    text: number;
+    /** Per covered edge it reaches into: pixels in from that edge's line. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+}
+/**
+ * A text block the frame's edges cut: what shows of its glyphs (the rows
+ * each line's glyphs cover, the columns of its letters, after the boxes it
+ * is drawn inside clip it) that lies outside the frame.
+ */
+export interface TextOffFrame {
+    text: number;
+    /** Pixels of its glyphs outside the frame. */
+    outside: number;
+    /** That as a share of its glyphs' pixels (0–1; 1: none of them inside). */
+    share: number;
+    /** Per edge of the frame it crosses: pixels past the edge. */
+    edges: {
+        side: "top" | "bottom" | "left" | "right";
+        px: number;
+    }[];
+    /** The box round its glyphs, whole pixels, the frame not cutting it. */
+    glyphs: Box;
+}
+export interface LayoutMoment {
+    /** Film seconds, on the frame grid. */
+    t: number;
+    part: string;
+    texts: MeasuredText[];
+    /** The speaker's face, when the footage showing has a face track. */
+    face?: Box;
+    /** Blocks of different layers over each other. */
+    overlaps: TextOverlap[];
+    /** Blocks of the same layer over each other. */
+    ownOverlaps: TextOverlap[];
+    /** Blocks reaching outside a box they are drawn inside. */
+    outside: TextOutside[];
+    faceOverlaps: FaceOverlap[];
+    safeOverlaps: SafeOverlap[];
+    /** Blocks the frame's edges cut. */
+    offFrame: TextOffFrame[];
+}
+/** A footage layer's enlargement at one moment. */
+export interface ScaleAt {
+    /** Output pixels per source pixel (1: its own pixels; 2: each source pixel drawn 2 × 2). */
+    scale: number;
+    /** Film seconds. */
+    t: number;
+    /** What makes up the scale then: the fit, and a zoom (punch-in or pullback) or box key. */
+    from: string[];
+}
+/**
+ * How much a footage layer is enlarged over its window: drawn pixels per
+ * source pixel at its largest and at its smallest.
+ */
+export interface FootageScale {
+    part: string;
+    file: string;
+    /** The source's pixels, as displayed. */
+    source: [width: number, height: number];
+    /** The part of the source drawn (crop, reframe window), in its pixels. */
+    shown: [width: number, height: number];
+    /** The largest enlargement, at its first moment. */
+    max: ScaleAt;
+    /** The smallest enlargement, at its first moment. */
+    min: ScaleAt;
+}
+/** How the time a text can be read is measured (the text-time fact). */
+export interface ReadOptions {
+    /** Seconds between the moments each part is looked at. */
+    every: number;
+    /** A block is whole while every text node of it is drawn at this opacity or more… */
+    opacity: number;
+    /** …and at least this share of each node's glyphs' box shows (an ancestor's overflow clips the rest). */
+    shown: number;
+    /**
+     * The phone a text's size is given on: its screen in points, held
+     * upright, the frame fitted inside it whole (a 16:9 frame across its
+     * width, a 9:16 one up its height).
+     */
+    phone: [width: number, height: number];
+}
+export declare const READ_DEFAULTS: ReadOptions;
+/** How many of the phone's points a pixel of a frame is (`ReadOptions.phone`). */
+export declare function phoneScale(frame: readonly [width: number, height: number], phone: readonly [width: number, height: number]): number;
+/** A text block at one of the moments a part is looked at. */
+export interface TextSample {
+    /** Film seconds. */
+    t: number;
+    text: string;
+    box: Box;
+    /** The lowest opacity of its text nodes. */
+    opacity: number;
+    /** The share of its glyphs' box that shows, the lowest of its text nodes' (an ancestor's overflow clips the rest). */
+    shown: number;
+    /** Its font size as drawn, in the frame's pixels (a transform's scale counted), the smallest of its text nodes'. */
+    size?: number;
+    /** Its font's lowercase x as drawn, in the frame's pixels, the smallest of its text nodes' with lowercase Latin letters. */
+    xHeight?: number;
+}
+/** How long one text block can be read. */
+export interface TextTime {
+    part: string;
+    /** The text the block shows longest, where it is first whole (else first on screen). */
+    text: MeasuredText;
+    words: number;
+    chars: number;
+    /** Seconds that text shows whole. */
+    seconds: number;
+    /** When, in film seconds: [from, until]. */
+    spans: [from: number, until: number][];
+    /** Seconds that text is on screen at all. */
+    onScreen: number;
+    /** Film seconds it is first whole, else first on screen. */
+    first: number;
+    /**
+     * Its font size: the smallest it is drawn at while whole (else while on
+     * screen), in the frame's pixels and in points on the phone of
+     * `ReadOptions.phone`. Missing when it was not measured. `lowercase` is
+     * the height of its font's lowercase x the same way, for text with
+     * lowercase Latin letters: two faces at one size can draw their letters
+     * at very different heights (a handwriting face's are much smaller).
+     */
+    size?: TextSize;
+}
+/** A text's size in the frame's pixels and in points on a phone, with its lowercase letters' height. */
+export interface TextSize {
+    px: number;
+    phone: number;
+    lowercase?: {
+        px: number;
+        phone: number;
+    };
+}
+/** A text of a deck's shape as drawn. */
+export interface DeckTextLayout {
+    text: string;
+    words: number;
+    /** Its lines as drawn, a box of each one's glyphs, in the slide's pixels. */
+    lines: Box[];
+    /** All of its glyphs; null when none shows. */
+    glyphs: Box | null;
+    /** The sizes and weights it is drawn at, each once: size and lowercase x's height in points. */
+    type: {
+        size: number;
+        weight: number;
+        xHeight?: number;
+    }[];
+    /** The share autofit shrank it to, when it did. */
+    scale?: number;
+    /** Its first paragraph's alignment: the line it is aligned by. */
+    align?: "l" | "ctr" | "r" | "just";
+}
+/** A deck's shape as drawn on its slide. */
+export interface DeckShapeLayout {
+    name: string;
+    /** placeholder, textbox, picture, movie, autoshape, line, component. */
+    kind: string;
+    /** Where it comes from: its master's or layout's own, or the slide's (placeholders are the slide's). */
+    level: "master" | "layout" | "slide";
+    placeholder?: string;
+    /** Its frame as set, in the slide's pixels. */
+    frame: Box;
+    /** Its box as drawn (a shape that fits its text has grown to it). */
+    box: Box;
+    /** It hides what is under it: filled, a picture, a movie. */
+    opaque: boolean;
+    /** Not drawn at this moment: its entrance is to come, or its exit has been. */
+    hidden?: boolean;
+    text?: DeckTextLayout;
+    /** A table's rows, each as tall as it is set and as it is drawn, in the slide's pixels. */
+    rows?: {
+        set: number;
+        drawn: number;
+    }[];
+    /** A chart's numbers: how many, how far they run, and the project file they came from. */
+    chart?: {
+        type: string;
+        categories: number;
+        series: number;
+        low?: number;
+        high?: number;
+        source?: string;
+    };
+    picture?: {
+        /** The file's own pixels. */
+        source: [width: number, height: number];
+        /** The part of them shown (its crop). */
+        shown: [width: number, height: number];
+    };
+}
+/** A deck's slide as drawn at a still: one of its steps'. */
+export interface DeckSlideLayout {
+    slide: string;
+    /** How many steps the slide has, so that all of them measured can be told. */
+    steps?: number;
+    /** Its still, in the deck's seconds. */
+    t: number;
+    layout: string;
+    hidden: boolean;
+    notes?: string;
+    /** Back to front, as drawn; an empty placeholder is not drawn. */
+    shapes: DeckShapeLayout[];
+}
+/** A deck as drawn, measured for its facts. */
+export interface DeckLayout {
+    /** The slide's pixels per point. */
+    pxPerPt: number;
+    /** The fonts its PowerPoint file names: its theme's, and those its text names itself. */
+    fonts?: {
+        name: string;
+        where: "theme" | "text";
+    }[];
+    slides: DeckSlideLayout[];
+}
+export interface LayoutReport {
+    width: number;
+    height: number;
+    /** A deck's slides as drawn (a deck's measure() only). */
+    deck?: DeckLayout;
+    /** The format's covered edges, in pixels. */
+    safe: SafeZone;
+    moments: LayoutMoment[];
+    footage: FootageScale[];
+    /** How long each text block can be read (a video measured at its default moments). */
+    reading?: {
+        options: ReadOptions;
+        texts: TextTime[];
+    };
+}
+/** The words and characters of a text: word-like segments as the language breaks them, and characters that are not spaces. */
+export declare function countWords(text: string): {
+    words: number;
+    chars: number;
+};
+/**
+ * How long one text block can be read, from what it showed at each moment
+ * its part was looked at (in order, `every` seconds apart; a moment it was
+ * not on screen has no sample). Its text is the one it shows longest (a
+ * line that comes in word by word, a number that counts up: what they
+ * settle on), the latest of equals. It is whole while it shows that text
+ * with every node at `opacity` or more and `shown` or more of its glyphs
+ * showing; each run of
+ * such moments counts from its first to `every` after its last, no later
+ * than `end`. Its size is the smallest its text is drawn at while whole
+(else while on screen), and on a phone the frame (`o.frame`) fitted in
+`options.phone`.
+ */
+export declare function textTime(samples: readonly TextSample[], o: {
+    part: string;
+    layer: string;
+    z: MeasuredText["z"];
+    end: number;
+    frame: [width: number, height: number];
+}, options?: ReadOptions): TextTime | undefined;
+/** How much of what a part says shows as text in that part (the speech-on-screen fact). */
+export interface SpeechShown {
+    /** Words the part says, and how many of them are in a text it shows. */
+    words: number;
+    shown: number;
+    /** The words said that no text shows, each once, in order. */
+    unshown: string[];
+}
+/** Words said against the texts on screen, by their letters: a caption's words are the words said. */
+export declare function speechShown(heard: string, texts: readonly string[]): SpeechShown;
+/** The words whole on screen at once in a part (the words-on-screen fact). */
+export interface WordsAtOnce {
+    part: string;
+    /** The most words whole at once, with the characters and text blocks they are. */
+    words: number;
+    chars: number;
+    texts: number;
+    /** The first stretch with that many, in film seconds. */
+    from: number;
+    until: number;
+    /** Every change of the count over the part: from `t` on, `words` whole in `texts` blocks. */
+    steps: {
+        t: number;
+        words: number;
+        texts: number;
+    }[];
+}
+/**
+ * How many words are whole on screen at once, per part: the text blocks'
+ * whole spans (textTime) laid over each other. A block counts its words
+ * from the start of a span up to its end. A part none of whose texts is
+ * ever whole has none.
+ */
+export declare function wordsAtOnce(texts: readonly TextTime[]): WordsAtOnce[];
+/** The pixels two boxes both cover. */
+export declare function overlapArea(a: Box | PixelRect, b: Box | PixelRect): number;
+/** How two boxes overlap: the area, and its share of the smaller box. */
+export declare function boxOverlap(a: Box | PixelRect, b: Box | PixelRect): {
+    area: number;
+    share: number;
+} | undefined;
+/**
+ * How far a box reaches into the covered edges of a frame W × H: pixels
+ * in from each covered edge's line, for the edges it crosses.
+ */
+export declare function safeEdges(b: Box | PixelRect, safe: SafeZone, W: number, H: number): SafeOverlap["edges"];
+/**
+ * How far a box reaches past the edges of another: pixels out per edge it
+ * crosses, whole pixels (under one is none).
+ */
+export declare function outsideEdges(b: Box | PixelRect, inside: Box | PixelRect): TextOutside["edges"];
+/**
+ * How much of a text's glyphs lies outside a frame W × H: `glyphs` are the
+ * boxes of what shows of them (a box per line), in the frame's pixels. The
+ * pixels outside, their share of all the glyphs' pixels, and per edge of
+ * the frame they cross, how far past it they reach (whole pixels: under
+ * one is none). Undefined when they cross no edge, or have no pixels.
+ */
+export declare function offFrame(glyphs: readonly (Box | PixelRect)[], W: number, H: number): Omit<TextOffFrame, "text"> | undefined;
+/** A text block the frame's edges cut at every measured moment of its part that shows it. */
+export interface CutThroughout {
+    part: string;
+    /** The block at the moment the frame cuts most of it. */
+    text: MeasuredText;
+    /** The measured moments that show it, film seconds: the frame cuts it at each. */
+    moments: number[];
+    /** The moment the frame cuts most of it. */
+    t: number;
+    /** At that moment: its glyphs outside the frame, as `TextOffFrame`. */
+    worst: Omit<TextOffFrame, "text">;
+}
+/**
+ * The text blocks a report's measured moments never show whole inside the
+ * frame: in a part, a block (a layer's text, the same at each moment) that
+ * the frame's edges cut at every moment it is on screen. A block that
+ * slides in from past an edge and comes to rest inside is whole at some
+ * moment, and is not one; each moment of it stays a text-off-frame fact.
+ * A block wholly past the edges at a moment is not on screen then, so not
+ * cut. A page viewport's text is not measured against the frame.
+ */
+export declare function cutThroughout(report: LayoutReport): CutThroughout[];
+/**
+ * The facts of one moment: overlaps between text blocks (of different
+ * layers, and of the same layer), blocks reaching outside a box they are
+ * drawn inside, text over the face and in the covered edges.
+ */
+export declare function measureMoment(o: {
+    t: number;
+    part: string;
+    texts: MeasuredText[];
+    face?: Box;
+    safe: SafeZone;
+    width: number;
+    height: number;
+    /** Which layer each text belongs to (an index): blocks of one layer and of two are told apart. */
+    owner: number[];
+    /**
+     * Per text, the boxes it is drawn inside, nearest first (absent: none
+     * measured). A block is compared with each in turn, and the nearest it
+     * reaches out of is reported.
+     */
+    containers?: (readonly TextContainer[] | undefined)[];
+    /**
+     * Per text, the box of what shows of its glyphs (MeasuredText.ink; absent:
+     * its box). Blocks of one layer are compared by it, and so is a block
+     * with the boxes it is drawn inside.
+     */
+    seen?: (Box | undefined)[];
+    /**
+     * Per text, the boxes of what shows of its glyphs, one per line, the
+     * frame's own edges not clipping them (absent: its `seen` box, else its
+     * box). The frame's edges are measured against them.
+     */
+    glyphs?: (readonly Box[] | undefined)[];
+}): LayoutMoment;
+/**
+ * How much a footage layer is enlarged over its window, at its largest and
+ * at its smallest: drawn pixels per source pixel, from the part of the
+ * source it shows (its crop, or the reframe window) and the picture it is
+ * drawn as, times its zoom (punch-ins, a pullback) and its box keys (a
+ * key's box against the first box, which places the picture). Measured at
+ * the window's first and last frames and at every key between them: eases
+ * move monotonically from key to key, so the extremes are at those
+ * moments. `outScale` is output pixels per drawn pixel (a small custom
+ * format is drawn larger and scaled down); `fps` puts the last moment on
+ * the window's last frame. Undefined when the source's size is not known.
+ */
+export declare function footageScale(f: Pick<TimelineFootage, "part" | "file" | "start" | "end" | "crop" | "picture" | "zoom" | "boxes" | "fit"> & {
+    source?: {
+        width: number;
+        height: number;
+    };
+}, outScale?: number, fps?: number): FootageScale | undefined;
+/** Rows of the frame, [y0, y1]: from the top edge y0 to the bottom edge y1, in pixels. */
+export type RowSpan = [y0: number, y1: number];
+/** A band across the content box that nothing measured covers. */
+export interface FreeBand {
+    /** Its rows, [top, bottom] edges in pixels. */
+    y: RowSpan;
+    /** Its columns: the content box's, [left, right] edges in pixels. */
+    x: [x0: number, x1: number];
+    /** y1 − y0. */
+    height: number;
+}
+/** The content box of a frame W × H: inside its covered edges, as columns and rows. */
+export declare function contentBox(W: number, H: number, safe: SafeZone): {
+    x: [number, number];
+    y: [number, number];
+};
+/** Spans joined where they overlap or touch, top to bottom; empty spans dropped. */
+export declare function unionSpans(spans: readonly RowSpan[]): RowSpan[];
+/**
+ * The bands of a content box that none of the spans covers, top to
+ * bottom, each the content box's width. No threshold: a band one pixel
+ * high is a band.
+ */
+export declare function freeBands(content: {
+    x: [number, number];
+    y: [number, number];
+}, covered: readonly RowSpan[]): FreeBand[];
+/**
+ * The rows a box covers where it reaches into the columns [x0, x1], rounded
+ * outwards to whole pixels; undefined when it does not reach them.
+ */
+export declare function boxRows(b: Box | PixelRect, x: readonly [number, number]): RowSpan | undefined;
+/** One thing on screen at one frame: a text block, a painted box, a picture. */
+export interface TrackSample {
+    /** Film seconds. */
+    t: number;
+    /** Its box in the frame's pixels; absent while it does not show. */
+    box?: Box;
+    /** 0 while it does not show. */
+    opacity: number;
+}
+/** A thing followed frame by frame through a part. */
+export interface Track {
+    part: string;
+    layer: string;
+    /** What it is: `text "…"`, `box`, or its tag for a picture (`img`, `svg`, `canvas`, `video`). */
+    what: string;
+    /** Where it is in the layer, as a selector. */
+    selector: string;
+    /** Its own `data-ak` name, when it has one (`named(el, name)`). */
+    name?: string;
+    /** One per frame looked at, in order. */
+    samples: TrackSample[];
+}
+/** A thing's largest change between two frames in a row, against the changes beside it. */
+export interface Step {
+    part: string;
+    layer: string;
+    what: string;
+    selector: string;
+    /** `move`: its box's centre and size; `fade`: its opacity. */
+    kind: "move" | "fade";
+    /** Film seconds of the later frame. */
+    t: number;
+    /** Its box before and after (a fade from or to nothing has only one). */
+    from?: Box;
+    to?: Box;
+    /** Pixels its centre moved, and the most a side grew or shrank. */
+    px: number;
+    grew: number;
+    /** Its opacity before and after. */
+    opacity: [before: number, after: number];
+    /**
+     * The same change over the frame before and the frame after, the larger
+     * of the two: a thing gliding has about as much, a thing jumping far
+     * less.
+     */
+    around: number;
+    /** The change less `around`: pixels for a move, opacity for a fade. */
+    over: number;
+}
+/**
+ * Each track's largest step of each kind: where its box moved or changed
+ * size the most over the change beside it, and where its opacity did. A
+ * measurement, not a verdict: a cut inside a layer and a glitch both show
+ * as a large step with little around it. Sorted by `over`, moves and fades
+ * apart (pixels and opacity are not one scale), moves first.
+ */
+export declare function largestSteps(tracks: readonly Track[]): Step[];
+//# sourceMappingURL=measure.d.ts.map

package/dist/node_modules/@allyhub-next/video-core/dist/measure.js

@@ -0,0 +1,5 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{boxFit as F,zoomChannel as I}from"./footage-motion.js";import{keyAt as $,rectAt as L}from"./motion.js";export const READ_DEFAULTS={every:.2,opacity:.9,shown:.9,phone:[390,844]};export function phoneScale(t,o){return Math.min(o[0]/t[0],o[1]/t[1])}export function countWords(t){let o=0;for(const e of new Intl.Segmenter(void 0,{granularity:"word"}).segment(t))e.isWordLike&&o++;let a=0;for(const e of new Intl.Segmenter(void 0,{granularity:"grapheme"}).segment(t))e.segment.trim()!==""&&a++;return{words:o,chars:a}}export function textTime(t,o,a=READ_DEFAULTS){const e=new Map;for(const x of t)e.set(x.text,(e.get(x.text)??0)+1);let c,u=0;for(const x of t){const w=e.get(x.text)??0;w>=u&&(u=w,c=x.text)}if(c===void 0)return;const h=t.filter(x=>x.text===c),f=x=>x.opacity>=a.opacity-1e-9&&x.shown>=a.shown-1e-9,i=a.every,n=x=>g(Math.min(x+i,o.end)),r=[];for(const x of h){if(!f(x))continue;const w=r.at(-1);w&&x.t-w[1]<i*.5?w[1]=n(x.t):r.push([g(x.t),n(x.t)])}const p=h.find(f)??h[0];if(!p)return;const l=(h.some(f)?h.filter(f):h).flatMap(x=>x.size===void 0?[]:[x.size]),m=l.length>0?Math.min(...l):void 0,s=(h.some(f)?h.filter(f):h).flatMap(x=>x.xHeight===void 0?[]:[x.xHeight]),d=s.length>0?Math.min(...s):void 0,M=phoneScale(o.frame,a.phone),v=x=>g(x.reduce((w,[O,A])=>w+Math.max(0,A-O),0)),y=[];for(const x of h){const w=y.at(-1);w&&x.t-w[1]<i*.5?w[1]=n(x.t):y.push([g(x.t),n(x.t)])}return{part:o.part,text:{layer:o.layer,z:o.z,text:c,box:p.box},...countWords(c),seconds:v(r),spans:r,onScreen:v(y),first:g(p.t),...m===void 0?{}:{size:{px:z(m),phone:z(m*M),...d===void 0?{}:{lowercase:{px:z(d),phone:z(d*M)}}}}}}const S=t=>t.toLowerCase().replace(/[^\p{L}\p{N}]/gu,"");export function speechShown(t,o){const a=new Set(o.flatMap(u=>u.split(/\s+/u).map(S))),e=t.split(/\s+/u).filter(u=>S(u)!==""),c=e.filter(u=>!a.has(S(u)));return{words:e.length,shown:e.length-c.length,unshown:[...new Set(c.map(S))]}}export function wordsAtOnce(t){const o=new Map;for(const e of t){if(e.spans.length===0)continue;const c=o.get(e.part)??[];c.push(e),o.set(e.part,c)}const a=[];for(const[e,c]of o){const u=[...new Set(c.flatMap(i=>i.spans.flat()))].sort((i,n)=>i-n),h=[];let f;for(const[i,n]of u.entries()){const r=c.filter(m=>m.spans.some(([s,d])=>n>=s&&n<d)),p=r.reduce((m,s)=>m+s.words,0),l=h.at(-1);(l?.words!==p||l.texts!==r.length)&&h.push({t:n,words:p,texts:r.length}),r.length>0&&(!f||p>f.words)?f={words:p,chars:r.reduce((m,s)=>m+s.chars,0),texts:r.length,from:n,until:u[i+1]??n}:f?.until===n&&p===f.words&&(f.until=u[i+1]??n)}f&&a.push({part:e,...f,steps:h})}return a}const b=t=>Math.max(0,t[2])*Math.max(0,t[3]);export function overlapArea(t,o){const a=Math.min(t[0]+t[2],o[0]+o[2])-Math.max(t[0],o[0]),e=Math.min(t[1]+t[3],o[1]+o[3])-Math.max(t[1],o[1]);return a>0&&e>0?a*e:0}const g=t=>Math.round(t*1e3)/1e3,z=t=>Math.round(t*10)/10;export function boxOverlap(t,o){const a=overlapArea(t,o);if(a<=0)return;const e=Math.min(b(t),b(o));return{area:Math.round(a),share:e>0?g(a/e):0}}export function safeEdges(t,o,a,e){const[c,u,h,f]=t;return[["top",o.top>0?o.top-u:0],["bottom",o.bottom>0?u+f-(e-o.bottom):0],["left",o.left>0?o.left-c:0],["right",o.right>0?c+h-(a-o.right):0]].filter(([,n])=>n>=1).map(([n,r])=>({side:n,px:Math.round(r)}))}export function outsideEdges(t,o){return[["top",o[1]-t[1]],["bottom",t[1]+t[3]-(o[1]+o[3])],["left",o[0]-t[0]],["right",t[0]+t[2]-(o[0]+o[2])]].filter(([,e])=>e>=1).map(([e,c])=>({side:e,px:Math.round(c)}))}export function offFrame(t,o,a){let e=0,c=0;const u={top:0,bottom:0,left:0,right:0};let[h,f,i,n]=[1/0,1/0,-1/0,-1/0];for(const s of t)s[2]<=0||s[3]<=0||(h=Math.min(h,s[0]),f=Math.min(f,s[1]),i=Math.max(i,s[0]+s[2]),n=Math.max(n,s[1]+s[3]),e+=b(s),c+=overlapArea(s,[0,0,o,a]),u.top=Math.max(u.top,-s[1]),u.bottom=Math.max(u.bottom,s[1]+s[3]-a),u.left=Math.max(u.left,-s[0]),u.right=Math.max(u.right,s[0]+s[2]-o));if(e<=0)return;const r=["top","bottom","left","right"].filter(s=>u[s]>=1).map(s=>({side:s,px:Math.round(u[s])}));if(r.length===0)return;const p=Math.max(0,e-c),l=Math.round(h),m=Math.round(f);return{outside:Math.round(p),share:g(p/e),edges:r,glyphs:[l,m,Math.round(i)-l,Math.round(n)-m]}}export function cutThroughout(t){const o=new Map;for(const e of t.moments){const c=new Map(e.offFrame.map(h=>[h.text,h])),u=new Set;e.texts.forEach((h,f)=>{if(h.viewport)return;const i=c.get(f);if(i&&i.share>=1)return;const n=`${e.part}
+${h.layer}
+${h.z}
+${h.text}`;if(u.has(n))return;u.add(n);let r=o.get(n);if(r||(r={part:e.part,shown:0,cut:void 0},o.set(n,r)),r.shown++,!i)return;const p={outside:i.outside,share:i.share,edges:i.edges,glyphs:i.glyphs};if(!r.cut){r.cut={part:e.part,text:h,moments:[e.t],t:e.t,worst:p};return}r.cut.moments.push(e.t),i.share>r.cut.worst.share&&(r.cut.text=h,r.cut.t=e.t,r.cut.worst=p)})}const a=[];for(const e of o.values())e.cut?.moments.length===e.shown&&a.push(e.cut);return a}export function measureMoment(t){const o=[],a=[],e=n=>t.seen?.[n]??t.texts[n]?.box;for(let n=0;n<t.texts.length;n++)for(let r=n+1;r<t.texts.length;r++){const p=t.texts[n],l=t.texts[r];if(!p||!l)continue;if(t.owner[n]===t.owner[r]){const s=e(n),d=e(r),M=s&&d?boxOverlap(s,d):void 0;M&&a.push({a:n,b:r,...M});continue}const m=boxOverlap(p.box,l.box);m&&o.push({a:n,b:r,...m})}const c=[];t.texts.forEach((n,r)=>{const p=e(r);if(!(!p||n.viewport))for(const l of t.containers?.[r]??[]){const m=outsideEdges(p,l.box);if(m.length!==0){c.push({text:r,container:l,edges:m});break}}});const u=[],h=t.face;h&&t.texts.forEach((n,r)=>{const p=overlapArea(n.box,h);p<=0||u.push({text:r,area:Math.round(p),ofText:g(p/Math.max(1,b(n.box))),ofFace:g(p/Math.max(1,b(h)))})});const f=[];t.texts.forEach((n,r)=>{if(n.viewport)return;const p=safeEdges(n.box,t.safe,t.width,t.height);p.length>0&&f.push({text:r,edges:p})});const i=[];return t.texts.forEach((n,r)=>{if(n.viewport)return;const p=e(r),l=offFrame(t.glyphs?.[r]??(p?[p]:[]),t.width,t.height);l&&i.push({text:r,...l})}),{t:t.t,part:t.part,texts:t.texts,...h?{face:h}:{},overlaps:o,ownOverlaps:a,outside:c,faceOverlaps:u,safeOverlaps:f,offFrame:i}}export function footageScale(t,o=1,a){const e=t.crop;if(!e||!t.source||e[2]<=0||e[3]<=0)return;const c=t.picture,u=t.zoom&&t.zoom.length>0?I(t.zoom,"z"):[],h=t.boxes&&t.boxes.length>1?t.boxes:void 0,f=h?.[0]?.box,i=h?.map(s=>({t:s.t,rect:s.box,...s.ease?{ease:s.ease}:{}})),n=Math.max(t.start,a?t.end-1/a:t.end),r=[t.start,...u.map(s=>s.t),...(h??[]).map(s=>s.t),n].map(s=>Math.min(Math.max(s,t.start),n)).sort((s,d)=>s-d),p=s=>{const d=u.length>0?$(u,s):1,M=i&&f?F(t,f,L(i,s)):1,v=Math.max(c[2]*M/e[2],c[3]*M/e[3])*d*o,y=[t.fit];return Math.abs(d-1)>1e-6&&y.push(`zoom ${String(g(d))}×`),i&&Math.abs(M-1)>1e-6&&y.push(`box key ${String(g(M))}×`),{scale:g(v),t:g(s),from:y}};let l=p(t.start),m=l;for(const s of r){const d=p(s);d.scale>l.scale&&(l=d),d.scale<m.scale&&(m=d)}return{part:t.part,file:t.file,source:[t.source.width,t.source.height],shown:[Math.round(e[2]),Math.round(e[3])],max:l,min:m}}export function contentBox(t,o,a){return{x:[a.left,Math.max(a.left,t-a.right)],y:[a.top,Math.max(a.top,o-a.bottom)]}}export function unionSpans(t){const o=t.filter(([e,c])=>c>e).map(([e,c])=>[e,c]).sort((e,c)=>e[0]-c[0]),a=[];for(const e of o){const c=a.at(-1);c&&e[0]<=c[1]?c[1]=Math.max(c[1],e[1]):a.push(e)}return a}export function freeBands(t,o){const[a,e]=t.y,c=[];let u=a;const h=(f,i)=>{i>f&&c.push({y:[f,i],x:[t.x[0],t.x[1]],height:i-f})};for(const[f,i]of unionSpans(o))if(!(i<=u)){if(f>=e)break;h(u,Math.min(f,e)),u=Math.max(u,i)}return h(u,e),c}export function boxRows(t,o){if(!(t[2]<=0||t[3]<=0)&&!(t[0]>=o[1]||t[0]+t[2]<=o[0]))return[Math.floor(t[1]),Math.ceil(t[1]+t[3])]}const E=t=>[t[0]+t[2]/2,t[1]+t[3]/2];function k(t,o){if(!t.box||!o.box)return{px:0,grew:0};const[a,e]=E(t.box),[c,u]=E(o.box);return{px:Math.hypot(c-a,u-e),grew:Math.max(Math.abs(o.box[2]-t.box[2]),Math.abs(o.box[3]-t.box[3]))}}export function largestSteps(t){const o=[];for(const e of t){const c=e.samples.length,u=[],h=[];for(let f=1;f<c;f++){const i=e.samples[f-1],n=e.samples[f];if(!i||!n)continue;const r=k(i,n);u[f]=Math.max(r.px,r.grew),h[f]=Math.abs(n.opacity-i.opacity)}for(const[f,i]of[["move",u],["fade",h]]){let n=-1,r=0;for(let s=1;s<c;s++){const M=(i[s]??0)-Math.max(i[s-1]??0,i[s+1]??0);M>r+1e-9&&(n=s,r=M)}const p=e.samples[n-1],l=e.samples[n];if(n<1||!p||!l)continue;const m=k(p,l);o.push({part:e.part,layer:e.layer,what:e.what,selector:e.selector,kind:f,t:g(l.t),...p.box?{from:p.box}:{},...l.box?{to:l.box}:{},px:g(m.px),grew:g(m.grew),opacity:[g(p.opacity),g(l.opacity)],around:g(Math.max(i[n-1]??0,i[n+1]??0)),over:g(r)})}}const a=e=>e.kind==="move"?0:1;return o.sort((e,c)=>a(e)-a(c)||c.over-e.over)}