allyhub 0.2.0-next.0 → 0.2.0-next.2

package/node_modules/@allyhub-next/video-core/LICENSE

@@ -0,0 +1,241 @@
+AllyHub Software License
+
+Copyright (c) 2026 AllyHub, Inc. ("AllyHub"). All rights reserved.
+
+This software (the AllyHub command-line tool, its SDK, runtime and the
+packages they depend on) is proprietary. It is not open source.
+
+1. Permitted use. You may install and run the software, unmodified, to make,
+   check, preview and render videos and decks, including for commercial
+   purposes. What you make with it is yours.
+
+2. Restrictions. Except as this license permits or applicable law requires,
+   you may not copy, modify, adapt, translate, sublicense, sell, rent, lease,
+   publish or otherwise distribute the software, create derivative works of
+   it, or reverse engineer, decompile or disassemble it.
+
+3. Cloud services. AllyHub's cloud tools (sign-in, research, images, voice,
+   video) are separate services governed by AllyHub's terms of service.
+
+4. Trademarks. This license grants no right to use the name "AllyHub" or its
+   logos.
+
+5. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+   KIND, EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+   ALLYHUB BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.
+
+6. Third-party code. Parts of the software are adapted from HyperFrames,
+   licensed under the Apache License, Version 2.0 (see NOTICE). Those parts
+   remain under that license, reproduced below, and nothing in this license
+   limits your rights under it.
+
+7. Starter components. The starter components in the "components" folder,
+   which "allyhub add" copies into your workspace, are licensed under the MIT
+   License (see components/LICENSE): once copied, you may change, use and
+   share them freely.
+
+--------------------------------------------------------------------------------
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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

@@ -0,0 +1,164 @@
+import type { Word } from "./media.js";
+/**
+ * A named place in a line, in characters of the line as shown: a point at
+ * `at`, or the stretch from `at` to `end`.
+ */
+export interface TextAnchor {
+    name: string;
+    at: number;
+    end?: number;
+}
+/** A piece of a line, `at` to `end` of it as shown, that is said as `speak`. */
+export interface SpokenSpan {
+    at: number;
+    end: number;
+    speak: string;
+}
+/** A line read: its words as shown, with its anchors and what is said another way. */
+export interface SaidLine {
+    text: string;
+    anchors: TextAnchor[];
+    spans: SpokenSpan[];
+}
+/** An anchor's name: letters, digits, `_` and `-`. */
+export declare const ANCHOR_NAME: RegExp;
+/** `text` has something that reads as an anchor. */
+export declare const hasAnchors: (text: string) => boolean;
+/** `text` has something that reads as <shown|said>. */
+export declare const hasSpans: (text: string) => boolean;
+/**
+ * A line as written, read: its words as shown, the anchors by where they
+ * sit in those words, the pieces said another way, and what is wrong. A
+ * start hugs the word after it and an end the word before it, wherever the
+ * spaces were written; one space goes with an anchor that had spaces both
+ * sides. Every anchor is returned, also a name written twice, so a draft
+ * that is wrong for a moment loses nothing.
+ */
+export declare function readAnchors(raw: string): SaidLine & {
+    problems: string[];
+};
+/** A line as written, read (see readAnchors), without what is wrong with it. */
+export declare function readLine(raw: string): SaidLine;
+/**
+ * The line as said: each <shown|said> piece by its said side. `at` gives
+ * the place in it of a place in the line as shown; `end` asks for the end
+ * of a stretch, which stops before a piece that is only said, where a
+ * start goes past it.
+ */
+export declare function spokenLine(line: SaidLine): {
+    text: string;
+    at(place: number, end: boolean): number;
+    /** The way back: the place in the line as shown of a place in the line as said. */
+    shown(place: number, end: boolean): number;
+};
+/** The line as written: its words with each anchor and each <shown|said> at its place. */
+export declare function writeAnchors(text: string, anchors: readonly TextAnchor[], spans?: readonly SpokenSpan[]): string;
+/** A line read, as written. */
+export declare const writeLine: (line: SaidLine) => string;
+/** A line as written, as its words are shown: no anchors, each piece by its shown side. */
+export declare const withoutAnchors: (raw: string) => string;
+/**
+ * The anchors after `removed` characters at `at` gave way to `inserted`
+ * new ones. An anchor stays with the words it was on: what is typed at a
+ * point or at a stretch's start goes after it, what is typed at a
+ * stretch's end goes inside. An anchor whose words went stays at the place
+ * they were; none is ever dropped.
+ */
+export declare function spliceAnchors(anchors: readonly TextAnchor[], at: number, removed: number, inserted: number): TextAnchor[];
+/**
+ * The pieces said another way after the same change. A piece keeps what
+ * is typed over its own words and nothing typed beside it, unless `grow`
+ * says what was typed at its end, or at its start, goes on the same word
+ * (a digit after a digit). One whose shown words all went goes with them;
+ * a piece that is only said stays.
+ */
+export declare function spliceSpans(spans: readonly SpokenSpan[], at: number, removed: number, inserted: number, grow?: {
+    start?: boolean;
+    end?: boolean;
+}): SpokenSpan[];
+/**
+ * A line with `removed` characters at `at` giving way to `insert`. What is
+ * typed right at the edge of a piece said another way joins it when it
+ * goes on the same word: "4" after "1" is "14", a space or a new word is not.
+ */
+export declare function editLine(line: SaidLine, at: number, removed: number, insert: string): SaidLine;
+/**
+ * The words of a line from `from` to `to`, trimmed, as a line of their
+ * own: with the anchors that start there (a stretch that runs on ends
+ * where these words do) and the pieces said another way that are whole in it.
+ */
+export declare function sliceLine(line: SaidLine, from: number, to: number): SaidLine;
+/** Two lines as one, a space between their words. */
+export declare function joinLines(a: SaidLine, b: SaidLine): SaidLine;
+/** A stretch of a text that gave way: `removed` characters at `at`, for `inserted` at `into` of the new text. */
+export interface TextChange {
+    at: number;
+    removed: number;
+    into: number;
+    inserted: number;
+}
+/**
+ * Where `after` differs from `before`: each stretch of `before` that gave
+ * way (`removed` characters at `at`) and how many took its place (at
+ * `into` of `after`), first to last. The longest run of pieces the two
+ * share stays; lines too long to compare so are one change in the middle.
+ */
+export declare function changesOf(before: string, after: string): TextChange[];
+/**
+ * The anchors of a line whose words changed from `before` to `after`:
+ * the words the two share keep their anchors, and where they differ the
+ * anchors go by spliceAnchors.
+ */
+export declare function moveAnchors(anchors: readonly TextAnchor[], before: string, after: string): TextAnchor[];
+/** A line with new words: its anchors and pieces moved with the words the two share. */
+export declare function rewordLine(line: SaidLine, words: string): SaidLine;
+/**
+ * A line as written with new words, what is written in it moved with
+ * them: for a text changed whole (a field of a table, an input method's text).
+ */
+export declare function rewordAnchored(raw: string, words: string): string;
+/**
+ * An anchor's place in the line as spoken: counted in the letters and
+ * digits before it (normText), which is how a line is matched to the words
+ * of its sound.
+ */
+export interface LineAnchor {
+    name: string;
+    at: number;
+    end?: number;
+}
+/**
+ * Anchors by the letters and digits before them. `through` is what the
+ * line goes through before it is said (its {name} variables filled), given
+ * the words up to an anchor.
+ */
+export declare function lineAnchors(text: string, anchors: readonly TextAnchor[], through?: (text: string) => string): LineAnchor[];
+/** "@form", "@/free", "@form+0.2": an anchor's name, which end, and a shift in seconds. */
+export interface ParsedAnchorRef {
+    name: string;
+    end: boolean;
+    shift: number;
+}
+/**
+ * A reference that names an anchor, read against the names a line has: a
+ * whole name wins over a name with a shift ("@step-2" is the anchor
+ * step-2 when there is one, else step shifted two seconds back).
+ * Undefined when it does not start with "@".
+ */
+export declare function parseAnchorRef(ref: string, names?: ReadonlySet<string>): ParsedAnchorRef | undefined;
+/**
+ * A line with one end of an anchor moved to a moment of its sound: to the
+ * start of the word that starts nearest `t` (or, for the end of a stretch,
+ * the end of the word that ends nearest). `words` are the words of the
+ * line's sound, on the clock `t` is on. Undefined when the line has no
+ * such anchor or end, has no sound, or the stretch would be left with no
+ * words in it.
+ */
+export declare function anchorAtTime(line: SaidLine, name: string, end: boolean, words: readonly Word[], t: number): SaidLine | undefined;
+/**
+ * What is wrong with writing `value` over `before` as a move of anchors:
+ * the two must have the same words and the same pieces said another way,
+ * and the same anchors by name, each still readable. Undefined when it is one.
+ */
+export declare function anchorMoveProblem(before: string, value: string): string | undefined;
+//# sourceMappingURL=anchors.d.ts.map

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

@@ -0,0 +1,148 @@
+/** An output's mix levels (`video({ mix })`), LUFS; each default is the audio package's. */
+export interface MixOptions {
+    /** Each part's speech; default -16. */
+    speech?: number;
+    /** The music while speech plays; default -20. */
+    music?: number;
+    /** The music where nobody speaks; default -16. */
+    musicAlone?: number;
+    /** Sound effects from files; built-in sounds move by the same amount from the default; default -22. */
+    sfx?: number;
+    /** Footage's own sound where nobody speaks; default -16. */
+    footage?: number;
+    /** Footage's own sound while speech plays; default -22. */
+    footageUnderSpeech?: number;
+    /**
+     * How the music dips under words: `db` below its level while speech
+     * plays (default -8), going down over `attack` seconds before a word
+     * (0.3), back up over `release` after one (1), and staying down
+     * through pauses shorter than `hold` (2).
+     */
+    duck?: {
+        db?: number;
+        attack?: number;
+        release?: number;
+        hold?: number;
+    };
+    /** The music's fade in at the start and out at the end, seconds; defaults 0.3 and 1.5 (at most a quarter of the video). */
+    musicFade?: {
+        in?: number;
+        out?: number;
+    };
+}
+/** The mix's settings with every default filled in. */
+export interface MixLevels {
+    speech: number;
+    music: number;
+    musicAlone: number;
+    sfx: number;
+    footage: number;
+    footageUnderSpeech: number;
+    duck: {
+        db: number;
+        attack: number;
+        release: number;
+        hold: number;
+    };
+    musicFade: {
+        in: number;
+        out: number;
+    };
+}
+export interface MasterOptions {
+    /**
+     * Integrated loudness, LUFS (-70 to 0); default the platform profile's,
+     * else -14. false keeps the mix's own level (peaks still limited).
+     */
+    lufs?: number | false;
+    /** True-peak ceiling, dBTP (-9 to 0); default -3 (AAC overshoots up to about 2 dB). */
+    truePeak?: number;
+}
+/** The master's targets, or false to keep the mix's level (its peaks still limited to `truePeak`). */
+export interface MasterTargets {
+    lufs: number | false;
+    truePeak: number;
+}
+export declare const BAND_TYPES: readonly ["highpass", "lowpass", "bandpass", "peak", "lowshelf", "highshelf"];
+export type BandType = (typeof BAND_TYPES)[number];
+/**
+ * A moment of the film a video-level option names: film seconds, an
+ * anchor of any part ("@drop", "@drop+0.2", "@/drop") or a part's key
+ * (its start), or a word reference in a part (`{ part, at }`: `at` as a
+ * layer's at, from that part's start).
+ */
+export type SoundMoment = number | string | {
+    part: string;
+    at: number | string;
+};
+/**
+ * A band's values from a moment of the film on: `at` is the moment (the
+ * music's own reference: film seconds, an anchor, a part or a word in a
+ * part), and what it leaves out is the band's own value.
+ */
+export interface BandKey<T = SoundMoment> {
+    at: T;
+    hz?: number;
+    db?: number;
+    q?: number;
+}
+/**
+ * One band of an equalizer: a pass (`highpass`, `lowpass`, `bandpass`,
+ * with its `q`, default a Butterworth's 0.707), a `peak` (`db` at `hz`,
+ * `q` default 1) or a shelf (`lowshelf`, `highshelf`: `db` under or over
+ * `hz`, `q` the shelf's slope, default 1). `keys` move its values over
+ * the film's clock (music only).
+ */
+export interface EqBand<T = SoundMoment> {
+    type: BandType;
+    hz: number;
+    db?: number;
+    q?: number;
+    keys?: BandKey<T>[];
+}
+/**
+ * A compressor: from `threshold` dB over the stem's loudness (its
+ * integrated loudness as shaped so far: 0 is at it, -6 six dB under), the
+ * level over it is divided by `ratio`.
+ */
+export interface SoundCompressor {
+    threshold: number;
+    /** Input dB over the threshold per output dB; default 2. */
+    ratio?: number;
+    /** The knee's width, dB; default 6. */
+    knee?: number;
+    /** Seconds to go down, and to come back up; defaults 0.01 and 0.15. */
+    attack?: number;
+    release?: number;
+    /** The detector's window, seconds (0: the peak); default 0.01. */
+    window?: number;
+}
+/** How a stem is shaped (`music: { filter, eq, compress }`, a sound's own). */
+export interface SoundShape<T = SoundMoment> {
+    /**
+     * An ffmpeg audio filter chain run on the file as it is decoded, on the
+     * file's own clock ("acompressor=ratio=3,deesser"): one chain, nothing
+     * that reads files, makes sound of its own or changes the timing.
+     */
+    filter?: string;
+    /** Equalizer bands, in order. */
+    eq?: EqBand<T>[];
+    /** A compressor after the bands. */
+    compress?: SoundCompressor;
+}
+/** A shape whose bands do not move (a sound effect's). */
+export type FixedShape = Omit<SoundShape, "eq"> & {
+    eq?: Omit<EqBand, "keys">[];
+};
+/** A shape resolved for the mix: its keys at film seconds. */
+export type ResolvedShape = SoundShape<number>;
+/**
+ * How a voice was recorded (`video({ mic })`, `part({ mic })`): a setup by
+ * name (studio, phone, lav), a setup's options with any value changed, or
+ * false (played as it is). Its fields and their checks are the audio
+ * package's recording; here it is only carried.
+ */
+export type VoiceSetting = string | Readonly<Record<string, unknown>> | false;
+/** A voice setting resolved over its presets, as the audio package resolves it. */
+export type ResolvedVoice = Readonly<Record<string, unknown>>;
+//# sourceMappingURL=audio-types.d.ts.map

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

@@ -0,0 +1,87 @@
+/**
+ * The softness of the person's edge over a treated background when the
+ * layer does not say (`background.feather`): px at 1080p.
+ */
+export declare const MATTE_FEATHER = 2;
+/**
+ * How far the person's edge is pulled in then (`background.shrink`): px at
+ * 1080p. A little, so the rim of the old background the matte keeps round
+ * the person does not show against the new one.
+ */
+export declare const MATTE_SHRINK = 4;
+/** The most `background.blur`, `feather` and `shrink` take, px at 1080p. */
+export declare const BACKDROP_BLUR_MAX = 200;
+export declare const MATTE_FEATHER_MAX = 40;
+export declare const MATTE_SHRINK_MAX = 40;
+/**
+ * The frame's pixels in one "px at 1080p": a background's lengths (blur,
+ * feather, shrink) scale with the format's shorter side, so the same
+ * numbers look the same in every format.
+ */
+export declare function backdropUnit(width: number, height: number): number;
+/**
+ * A matte's levels are made firm before anything else: under the first
+ * (of 0–1) is none of the person, over the second all, a straight ramp
+ * between. A matte is a guess, and where it is unsure inside the person (a
+ * hand moving in front of the chest comes out at 0.9) the person is not
+ * see-through; its edge is then one clean line to soften and pull in.
+ */
+export declare const MATTE_FIRM: readonly [number, number];
+/** The firm level (0–255) of each level of a matte (0–255). */
+export declare function firmLevels(): Uint8ClampedArray;
+/** The same as an ffmpeg expression of `val` (0–255), for the lut filter. */
+export declare function firmLevelsExpr(): string;
+/**
+ * How a matte becomes the person's alpha: made firm (firmLevels), blurred
+ * by `sigma`, then each level m (0–1) becomes m / (m + gain × (1 − m)).
+ */
+export interface MatteEdge {
+    /** Gaussian blur of the matte, its standard deviation in the frame's pixels (0: none). */
+    sigma: number;
+    /** Over 1 pulls the edge in, under 1 lets it out, 1 leaves it. */
+    gain: number;
+}
+/**
+ * After the blur, a matte's lowest and highest levels count as none and
+ * all of the person: a little of each end, so that a level one short of
+ * all (the blur's rounding) does not make the whole person see-through
+ * once the edge is pulled in.
+ */
+export declare const MATTE_FLOOR = 6;
+/**
+ * The person's edge from a matte: `feather` softens it and `shrink` pulls
+ * it in (negative: lets it out), both in the frame's pixels; `scale` is
+ * the frame's pixels per matte pixel (a matte is smaller than the picture,
+ * so its edge, made firm, is still about a fifth of a matte pixel soft).
+ *
+ * The firm matte is blurred, which makes its edge an S-shaped ramp around
+ * where it was, as soft as the feather and the matte's own softness
+ * together. Sliding that ramp `shrink` pixels along is, on its levels,
+ * m → m / (m + gain × (1 − m)) with gain = exp(1.702 × shrink / softness)
+ * (the logistic curve that follows a Gaussian edge within a hundredth). A
+ * shrink the ramp is too narrow for (over 1.5 times its softness, where
+ * the levels left would be too few) widens the blur.
+ */
+export declare function matteEdge(feather: number, shrink: number, scale: number): MatteEdge;
+/** The person's alpha (0–255) for each level of a blurred matte (0–255). */
+export declare function edgeLevels(edge: MatteEdge): Uint8ClampedArray;
+/**
+ * The same levels as an ffmpeg expression of `val` (0–255), for the lut
+ * filter.
+ */
+export declare function edgeLevelsExpr(edge: MatteEdge): string;
+/**
+ * How much smaller a background is blurred: a blur of standard deviation
+ * `sigma` (pixels) holds no detail finer than about a third of it, so the
+ * picture is blurred at 1/2, 1/4 or 1/8 of its size and scaled back.
+ */
+export declare function blurStep(sigma: number): 1 | 2 | 4 | 8;
+/**
+ * The colour matrix of a background's `desaturate` and `dim` (each 0–1):
+ * rows for red, green and blue out, columns for red, green and blue in.
+ * The same as CSS `saturate(1 − desaturate) brightness(1 − dim)`.
+ */
+export declare function backdropMatrix(desaturate: number, dim: number): [Row, Row, Row];
+/** A row of a colour matrix: how much of red, green and blue goes into one channel. */
+export type Row = [r: number, g: number, b: number];
+//# sourceMappingURL=backdrop.d.ts.map