@gentbajko/slopify 2.3.0 → 2.4.0

package/dist/slices/shorts/captions.js

@@ -0,0 +1,272 @@
+// The shorts' captions: big, centred a little below the middle of the 9:16 frame, two to
+// four words on screen at a time, and the word being spoken drawn in a strong colour. Built
+// as ASS so the render burns them in with the same `ass` filter and font folder the video's
+// captions use. Pure.
+// Groups break at a sentence end, after a comma once they hold two words, at a pause, and
+// at four words.
+const groupMost = 4;
+const groupPause = 0.6;
+// A word left alone joins a neighbour across a pause up to this long; across a longer one
+// the neighbour would hang on screen through the silence.
+const joinPause = 1.5;
+// A group stays on screen this long after its last word, unless the next one starts first,
+// so a short pause doesn't flash an empty frame.
+const holdSeconds = 0.5;
+// ceiling: 7.5% of the height is about 144 px on 1080×1920, which fits twelve characters of
+// a typical sans-serif per line inside the side margins.
+const fontShare = 0.075;
+const lineCharacters = 12;
+const sideMargin = 80;
+// A little below the middle: clear of the face-height centre of most images, and clear of
+// the title and buttons the apps draw along the bottom.
+const heightShare = 0.62;
+// ASS colours are &HAABBGGRR. White for the words around it, gold for the one being spoken.
+const white = "&H00FFFFFF";
+const spoken = "&H0000D4FF";
+// ceiling: the title headline starts at 6% of the height (115 px) and shrinks to 3.5% until
+// it fits two lines. Barlow Bold averages about a third of its size per letter; 0.45 leaves
+// room for wider fonts a project may caption in.
+const titleShares = [0.06, 0.055, 0.05, 0.045, 0.04, 0.035];
+const letterWidth = 0.45;
+// Below the status bar, search and camera buttons the apps draw along the top: 11% of the
+// height is 211 px on 1920.
+const titleTop = 0.11;
+// The word times of a clip played `speed` times faster: every time divided, so the captions
+// stay on the words as they are heard.
+export function fasterWords(words, speed) {
+    if (speed === 1)
+        return words;
+    return words.map((word) => ({
+        ...word,
+        start: millis(word.start / speed),
+        end: millis(word.end / speed),
+    }));
+}
+// The words said inside the clip, with their times moved to the clip's own timeline and
+// clamped to it. A word is kept when most of it falls inside the clip.
+export function clipWords(words, start, end) {
+    const length = end - start;
+    return words
+        .filter((word) => (word.start + word.end) / 2 >= start && (word.start + word.end) / 2 <= end)
+        .map((word) => ({
+        text: word.text.replace(/\s+/g, " ").trim(),
+        start: millis(clamp(word.start - start, 0, length)),
+        end: millis(clamp(word.end - start, 0, length)),
+    }))
+        .filter((word) => word.text !== "" && word.end > word.start);
+}
+export function captionGroups(words) {
+    const groups = [];
+    let current = [];
+    const close = () => {
+        if (current.length > 0)
+            groups.push(current);
+        current = [];
+    };
+    for (const word of words) {
+        const previous = current.at(-1);
+        if (previous !== undefined && word.start - previous.end > groupPause)
+            close();
+        current.push(word);
+        if (current.length >= groupMost ||
+            sentenceEnd(word.text) ||
+            (current.length >= 2 && /[,;:]["'’”)]*$/.test(word.text)))
+            close();
+    }
+    close();
+    // Every change leaves one word fewer on its own, so this ends.
+    let changed = true;
+    while (changed) {
+        changed = groups.some((group, at) => group.length === 1 && keepCompany(groups, at));
+        for (let at = groups.length - 1; at >= 0; at--)
+            if (groups[at]?.length === 0)
+                groups.splice(at, 1);
+    }
+    return groups;
+}
+// A word left on its own would flash by alone, so it joins a neighbouring group: the one
+// before it, or, when it opens a sentence, the one after it first. When the neighbour is
+// too wide to take it, the neighbour's nearest word comes over to make a pair instead,
+// as long as that leaves the neighbour two words. It stays alone only after a long
+// silence, or between neighbours of one or two words that cannot fit it. Returns whether
+// the groups changed.
+function keepCompany(groups, at) {
+    const lone = groups[at];
+    const word = lone?.[0];
+    if (lone === undefined || word === undefined)
+        return false;
+    const before = groups[at - 1];
+    const after = groups[at + 1];
+    const opensSentence = before?.at(-1) !== undefined && sentenceEnd(before.at(-1)?.text ?? "");
+    // Words either side of a long silence stay apart: joined, one would sit on screen through it.
+    const near = (left, right) => left !== undefined && right !== undefined && right.start - left.end <= joinPause;
+    const tries = [
+        () => {
+            if (before === undefined || !near(before.at(-1), word))
+                return false;
+            if (!fits([...before, word], before))
+                return false;
+            before.push(word);
+            lone.length = 0;
+            return true;
+        },
+        () => {
+            if (after === undefined || !near(word, after[0]))
+                return false;
+            if (!fits([word, ...after], after))
+                return false;
+            after.unshift(word);
+            lone.length = 0;
+            return true;
+        },
+        () => {
+            const moved = before?.at(-1);
+            if (before === undefined || before.length < 3 || !near(moved, word))
+                return false;
+            before.pop();
+            if (moved !== undefined)
+                lone.unshift(moved);
+            return true;
+        },
+        () => {
+            const moved = after?.[0];
+            if (after === undefined || after.length < 3 || !near(word, moved))
+                return false;
+            after.shift();
+            if (moved !== undefined)
+                lone.push(moved);
+            return true;
+        },
+    ];
+    const order = opensSentence ? [1, 3, 0, 2] : [0, 2, 1, 3];
+    return order.some((index) => tries[index]?.() === true);
+}
+// A group with one more word fits when it holds at most one word over the usual most and
+// its longest line is no wider than a line holds, or than the group's own longest already
+// was.
+function fits(merged, group) {
+    const widest = (words) => longestLine(words.map((one) => one.text));
+    return (merged.length <= groupMost + 1 && widest(merged) <= Math.max(lineCharacters, widest(group)));
+}
+function sentenceEnd(text) {
+    return /[.!?]["'’”)]*$/.test(text);
+}
+export function shortCaptionsAss(words, style) {
+    const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    const size = Math.round(style.height * fontShare);
+    const position = `{\\an5\\pos(${String(style.width / 2)},${String(Math.round(style.height * heightShare))})}`;
+    const title = style.title === undefined || style.title.text.trim() === ""
+        ? undefined
+        : { ...titleLayout(style.title.text, style), seconds: style.title.seconds };
+    const header = `[Script Info]\nScriptType: v4.00+\nPlayResX: ${String(style.width)}\nPlayResY: ${String(style.height)}\nWrapStyle: 2\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Short,${name},${String(size)},${white},${white},&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,7,3,5,${String(sideMargin)},${String(sideMargin)},0,1\n${title === undefined ? "" : `Style: Title,${name},${String(title.size)},${white},${white},&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,6,3,8,${String(sideMargin)},${String(sideMargin)},0,1\n`}\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
+    const groups = captionGroups(words);
+    // The headline sits on a layer of its own, so a caption never hides it.
+    const events = title === undefined
+        ? []
+        : [
+            `Dialogue: 1,${assStamp(0)},${assStamp(title.seconds)},Title,,0,0,0,,{\\an8\\pos(${String(style.width / 2)},${String(Math.round(style.height * titleTop))})}${title.lines.map(assText).join("\\N")}\n`,
+        ];
+    for (const [at, group] of groups.entries()) {
+        const next = groups[at + 1]?.[0];
+        const last = group.at(-1);
+        if (last === undefined)
+            continue;
+        const shown = next === undefined ? last.end + holdSeconds : Math.min(last.end + holdSeconds, next.start);
+        const lines = lineBreaks(group.map((word) => word.text));
+        for (const [index, word] of group.entries()) {
+            const from = word.start;
+            const to = group[index + 1]?.start ?? Math.max(shown, word.end);
+            if (to <= from)
+                continue;
+            const text = group
+                .map((one, place) => {
+                const escaped = assText(one.text);
+                const shownWord = place === index
+                    ? `{\\c${spoken}&\\fscx108\\fscy108}${escaped}{\\c${white}&\\fscx100\\fscy100}`
+                    : escaped;
+                return `${shownWord}${lines.has(place) ? "\\N" : place < group.length - 1 ? " " : ""}`;
+            })
+                .join("");
+            events.push(`Dialogue: 0,${assStamp(from)},${assStamp(to)},Short,,0,0,0,,${position}${text}\n`);
+        }
+    }
+    return header + events.join("");
+}
+// The places after which a group breaks onto a second line: none when it fits on one,
+// otherwise the one break that makes the longer line shortest.
+function lineBreaks(texts, fit = lineCharacters) {
+    const total = texts.join(" ").length;
+    if (total <= fit || texts.length < 2)
+        return new Set();
+    let best = 0;
+    let bestLongest = Number.POSITIVE_INFINITY;
+    for (let after = 0; after < texts.length - 1; after++) {
+        const top = texts.slice(0, after + 1).join(" ").length;
+        const bottom = texts.slice(after + 1).join(" ").length;
+        const longest = Math.max(top, bottom);
+        if (longest < bestLongest) {
+            bestLongest = longest;
+            best = after;
+        }
+    }
+    return new Set([best]);
+}
+// The characters of the longest line the words are drawn on.
+function longestLine(texts) {
+    return Math.max(...splitAt(texts, lineBreaks(texts)).map((line) => line.length));
+}
+// The title headline: the largest size at which it fits two lines inside the side margins,
+// broken where the longer line is shortest; at the smallest size a title still too long is
+// cut at a word and ends in an ellipsis.
+export function titleLayout(title, style) {
+    const words = title
+        .replace(/\s+/g, " ")
+        .trim()
+        .split(" ")
+        .filter((word) => word !== "");
+    const room = (share) => Math.floor((style.width - 2 * sideMargin) / (style.height * share * letterWidth));
+    const laid = (share, texts) => {
+        const fit = room(share);
+        const breaks = lineBreaks(texts, fit);
+        const lines = breaks.size === 0 ? [texts.join(" ")] : splitAt(texts, breaks);
+        return { size: Math.round(style.height * share), lines, fit };
+    };
+    for (const share of titleShares) {
+        const layout = laid(share, words);
+        if (layout.lines.every((line) => line.length <= layout.fit))
+            return { size: layout.size, lines: layout.lines };
+    }
+    const smallest = titleShares.at(-1) ?? 0.03;
+    const fit = room(smallest);
+    const kept = [];
+    for (const word of words) {
+        if ([...kept, word].join(" ").length + 1 > fit * 2 - 1)
+            break;
+        kept.push(word);
+    }
+    const layout = laid(smallest, [...kept.slice(0, -1), `${kept.at(-1) ?? ""}…`]);
+    return { size: layout.size, lines: layout.lines };
+}
+function splitAt(texts, breaks) {
+    const lines = [[]];
+    for (const [at, text] of texts.entries()) {
+        lines.at(-1)?.push(text);
+        if (breaks.has(at))
+            lines.push([]);
+    }
+    return lines.map((line) => line.join(" "));
+}
+function assText(text) {
+    // Full-width alternatives stay visible and cannot open an ASS override or escape.
+    return text.replaceAll("\\", "＼").replaceAll("{", "｛").replaceAll("}", "｝");
+}
+function assStamp(seconds) {
+    const cs = Math.max(0, Math.round(seconds * 100));
+    return `${String(Math.floor(cs / 360_000))}:${String(Math.floor(cs / 6000) % 60).padStart(2, "0")}:${String(Math.floor(cs / 100) % 60).padStart(2, "0")}.${String(cs % 100).padStart(2, "0")}`;
+}
+function millis(seconds) {
+    return Math.round(seconds * 1000) / 1000;
+}
+function clamp(value, low, high) {
+    return Math.min(high, Math.max(low, value));
+}

package/dist/slices/shorts/clips.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { clipBounds, shortPickSchema } from "./pick.js";
+// What the pick saves in its payload. `sentences` (the numbered transcript's times and
+// words) came with hand-set ranges; a pick saved before them has none, and its clips can
+// only be adjusted after the moments are picked again.
+export const pickedShortsSchema = z.object({
+    shorts: z.array(shortPickSchema),
+    durationSeconds: z.number().finite().nonnegative().optional(),
+    sentences: z
+        .array(z.object({
+        start: z.number().finite().nonnegative(),
+        end: z.number().finite().nonnegative(),
+        text: z.string(),
+    }))
+        .optional(),
+});
+export function pickedShortsOf(payload) {
+    if (payload === null || payload === undefined)
+        return undefined;
+    try {
+        const parsed = pickedShortsSchema.safeParse(JSON.parse(payload));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Why a hand-set range can't be used, in the words Edit project shows under the clip; or
+// undefined when it can.
+export function rangeProblem(picked, number, first, last, limits, others = []) {
+    const sentences = picked.sentences;
+    if (sentences === undefined || sentences.length === 0)
+        return "These shorts were picked before clips could be adjusted by hand. Use Pick different moments, then adjust the new clips.";
+    if (!picked.shorts.some((clip) => clip.number === number))
+        return `There is no short ${String(number)} any more. Reload the page and choose again.`;
+    if (!Number.isInteger(first) ||
+        !Number.isInteger(last) ||
+        first < 1 ||
+        last > sentences.length ||
+        first > last)
+        return `Choose a start sentence that comes before the end sentence, between 1 and ${String(sentences.length)}.`;
+    const bounds = clipBounds(sentences, first, last, durationOf(picked));
+    if (bounds === undefined)
+        return "Choose a start and an end sentence from the transcript.";
+    const seconds = bounds.end - bounds.start;
+    // The same hundredth-of-a-second allowance the pick is checked with.
+    if (seconds < limits.minSeconds - 0.01)
+        return `Short ${String(number)} would last ${String(Math.round(seconds))} seconds, shorter than the ${String(limits.minSeconds)}-second minimum. Start it earlier or end it later.`;
+    if (seconds > limits.maxSeconds + 0.01)
+        return `Short ${String(number)} would last ${String(Math.round(seconds))} seconds, longer than the ${String(limits.maxSeconds)}-second maximum. Start it later or end it earlier.`;
+    const clash = others.find((clip) => clip.number !== number && first <= clip.last && last >= clip.first);
+    if (clash !== undefined)
+        return `Short ${String(number)} would share sentences with short ${String(clash.number)} (sentences ${String(clash.first)}-${String(clash.last)}). Choose a range that doesn't overlap it.`;
+    return undefined;
+}
+// The picked clips with every usable hand-set range in place: the model's title,
+// description and hashtags stay, the sentences, times and words are the range's. A range
+// set against another pick, or one that no longer fits the limits, is left out.
+export function effectiveClips(picked, ranges, pick, limits) {
+    const sentences = picked.sentences;
+    if (ranges === undefined || sentences === undefined)
+        return picked.shorts;
+    const clips = [...picked.shorts];
+    for (const [at, clip] of clips.entries()) {
+        const range = ranges[String(clip.number)];
+        if (range === undefined || range.pick !== pick)
+            continue;
+        if (rangeProblem(picked, clip.number, range.first, range.last, limits, clips) !== undefined)
+            continue;
+        const bounds = clipBounds(sentences, range.first, range.last, durationOf(picked));
+        if (bounds === undefined)
+            continue;
+        clips[at] = {
+            ...clip,
+            first: range.first,
+            last: range.last,
+            start: bounds.start,
+            end: bounds.end,
+            text: sentences
+                .slice(range.first - 1, range.last)
+                .map((sentence) => sentence.text)
+                .join(" "),
+        };
+    }
+    return clips;
+}
+function durationOf(picked) {
+    return picked.durationSeconds ?? picked.sentences?.at(-1)?.end ?? 0;
+}

package/dist/slices/shorts/model.js

@@ -0,0 +1,186 @@
+// The Video stage's optional Shorts step: the text model picks the best self-contained
+// moments of the narration, each becomes a vertical 1080×1920 clip with its own images and
+// big word-by-word captions, and each gets a title, a one-line description and hashtags.
+// Browser-safe: Play, Edit project and the project page read these names and limits too.
+// ceiling: the owner's numbers. Ten clips of three minutes is already half an hour of
+// vertical video from one narration.
+export const shortsCountMin = 1;
+export const shortsCountMax = 10;
+export const shortsSecondsMin = 15;
+export const shortsSecondsMax = 180;
+export const defaultShorts = {
+    enabled: false,
+    count: 3,
+    minSeconds: 60,
+    maxSeconds: 120,
+    titleOnScreen: true,
+};
+// ceiling: faster than 1.25× the narration stops sounding natural even with the pitch kept;
+// the step is the smallest change a listener notices.
+export const shortsSpeedMin = 1;
+export const shortsSpeedMax = 1.25;
+export const shortsSpeedStep = 0.05;
+// Quiet enough to sit under a voice at full volume; the ducking lowers it further while
+// the narrator speaks.
+export const defaultMusicVolume = 15;
+export const fullVideoLinkMax = 2000;
+// What a short's description ends with when no link to the full video is set: a line to
+// paste it into before uploading.
+export const fullVideoPlaceholder = "[PASTE THE FULL VIDEO LINK HERE]";
+// The line every short's description ends with, pointing viewers to the whole video.
+export function fullVideoLine(link) {
+    const trimmed = link?.trim() ?? "";
+    return `Watch the full video: ${trimmed === "" ? fullVideoPlaceholder : trimmed}`;
+}
+// What Copy puts on the clipboard for one short: the title, the description ending with the
+// link line, and the hashtags.
+export function shortUploadText(clip, link) {
+    return [
+        clip.title,
+        "",
+        `${clip.description}\n${fullVideoLine(link)}`,
+        "",
+        clip.hashtags.join(" "),
+    ].join("\n");
+}
+// The playback speed the render uses: the setting when it is in range, else 1.
+export function shortsSpeedOf(settings) {
+    const speed = settings.speed;
+    return speed !== undefined &&
+        Number.isFinite(speed) &&
+        speed >= shortsSpeedMin &&
+        speed <= shortsSpeedMax
+        ? speed
+        : 1;
+}
+export function musicVolumeOf(settings) {
+    const volume = settings.musicVolume;
+    return volume !== undefined && Number.isFinite(volume) && volume >= 0 && volume <= 100
+        ? volume
+        : defaultMusicVolume;
+}
+// A short's title is shown over the clip on YouTube Shorts, TikTok and Reels; 60 characters
+// fits all three without being cut.
+export const shortTitleMax = 60;
+export const shortHashtagsMin = 3;
+export const shortHashtagsMax = 5;
+// The name Play, Edit project and the review summary show for the prompts used when none is
+// picked.
+export const defaultShortsPromptName = "Built-in";
+// What a project uses when no Shorts prompt from the library is picked. No keywords, so it
+// never asks Play for a field.
+export const defaultShortsPrompt = [
+    "Pick the moments of this video that work best as vertical shorts on YouTube Shorts, TikTok and Reels.",
+    "",
+    "- Each short must make sense on its own, to a viewer who has not seen the rest of the video: no references to earlier parts, no setup that pays off outside the clip.",
+    "- Open on a hook: the first sentence should make someone stop scrolling (a surprising fact, a question, a bold claim). Skip clips that start with filler or a transition.",
+    "- End on a complete thought, not mid-argument.",
+    "- Prefer the most surprising, useful or emotional moments over summaries, and don't pick two shorts that say the same thing.",
+    "- Title: at most 60 characters, plain words, no clickbait and no hashtags.",
+    "- Description: one line that says what the viewer learns or feels.",
+    "- Hashtags: 3-5, about the subject of that clip, most specific last.",
+].join("\n");
+// The style the shorts' images are written in when no Image prompt from the library is
+// picked.
+export const defaultShortsImagePrompt = [
+    "Vertical 9:16 images for a short video. Each image illustrates what is being said at that moment of the clip.",
+    "Cinematic, high-contrast and uncluttered, with the subject large and centred so it reads on a phone screen.",
+    "Leave the lower half calm: captions are drawn over the middle of the frame.",
+    "No text, letters, logos or watermarks in the image.",
+].join("\n");
+// How many images a clip gets: one per `imageSeconds` of the clip, the last running to the
+// end, and at least one.
+export function shortImageCount(clipSeconds, imageSeconds) {
+    if (!Number.isFinite(clipSeconds) || !Number.isFinite(imageSeconds) || imageSeconds <= 0)
+        return 1;
+    // A few milliseconds over a whole number of images is timing noise, not another image.
+    return Math.max(1, Math.ceil(clipSeconds / imageSeconds - 0.001));
+}
+// The most images the step can ask for: every clip at the longest length allowed. The cost
+// estimate charges this before the clips are picked.
+export function shortsImageUpperBound(settings, imageSeconds) {
+    return settings.count * shortImageCount(settings.maxSeconds, imageSeconds);
+}
+// The settings the typed extras stand for. A number that doesn't read as one comes back as
+// NaN, so `shortsSettingsProblems` refuses it where it was typed.
+export function shortsExtrasOf(form) {
+    const typed = (value) => value === undefined || value.trim() === "" ? undefined : Number(value);
+    const musicVolume = typed(form.musicVolume);
+    const speed = typed(form.speed);
+    const link = form.fullVideoLink?.trim() ?? "";
+    return {
+        ...(form.titleOnScreen === undefined ? {} : { titleOnScreen: form.titleOnScreen }),
+        ...(link === "" ? {} : { fullVideoLink: link }),
+        ...(musicVolume === undefined ? {} : { musicVolume }),
+        ...(speed === undefined ? {} : { speed }),
+    };
+}
+// The same settings as the forms show them.
+export function shortsExtrasForm(settings) {
+    return {
+        ...(settings?.titleOnScreen === undefined ? {} : { titleOnScreen: settings.titleOnScreen }),
+        ...(settings?.fullVideoLink === undefined ? {} : { fullVideoLink: settings.fullVideoLink }),
+        ...(settings?.musicVolume === undefined ? {} : { musicVolume: String(settings.musicVolume) }),
+        ...(settings?.speed === undefined ? {} : { speed: settings.speed.toFixed(2) }),
+    };
+}
+// The words a problem with one of the settings is said in; shared by admission, Play's
+// draft conversion and Edit project.
+export function shortsSettingsProblems(settings) {
+    const problems = [];
+    const whole = (value, min, max) => Number.isInteger(value) && value >= min && value <= max;
+    if (!whole(settings.count, shortsCountMin, shortsCountMax))
+        problems.push({
+            field: "count",
+            message: `Enter a whole number of shorts between ${shortsCountMin} and ${shortsCountMax}.`,
+        });
+    for (const field of ["minSeconds", "maxSeconds"])
+        if (!whole(settings[field], shortsSecondsMin, shortsSecondsMax))
+            problems.push({
+                field,
+                message: `Enter a whole number of seconds between ${shortsSecondsMin} and ${shortsSecondsMax}.`,
+            });
+    // Said against both numbers, so it shows under whichever one was just typed.
+    if (problems.every((problem) => problem.field === "count") &&
+        settings.minSeconds > settings.maxSeconds)
+        for (const field of ["minSeconds", "maxSeconds"])
+            problems.push({
+                field,
+                message: "The longest a short may be must be at least the shortest. Raise the maximum or lower the minimum.",
+            });
+    const speed = settings.speed;
+    // Steps of 0.05 from 1.00, allowing for how a typed or stored number was rounded.
+    if (speed !== undefined &&
+        (!Number.isFinite(speed) ||
+            speed < shortsSpeedMin - 1e-9 ||
+            speed > shortsSpeedMax + 1e-9 ||
+            Math.abs((speed - shortsSpeedMin) / shortsSpeedStep -
+                Math.round((speed - shortsSpeedMin) / shortsSpeedStep)) > 1e-6))
+        problems.push({
+            field: "speed",
+            message: "Choose a speed between 1.00× and 1.25×, in steps of 0.05.",
+        });
+    if (settings.musicVolume !== undefined && !whole(settings.musicVolume, 0, 100))
+        problems.push({
+            field: "musicVolume",
+            message: "Enter the music volume as a whole number of percent between 0 and 100.",
+        });
+    const link = settings.fullVideoLink?.trim() ?? "";
+    if (link !== "" && !webLink(link))
+        problems.push({
+            field: "fullVideoLink",
+            message: "The full video link must be a whole web address starting with https:// or http://, like https://youtu.be/abc123. Paste it again, or leave the box empty.",
+        });
+    return problems;
+}
+function webLink(text) {
+    if (text.length > fullVideoLinkMax || /\s/.test(text))
+        return false;
+    try {
+        const url = new URL(text);
+        return (url.protocol === "https:" || url.protocol === "http:") && url.hostname !== "";
+    }
+    catch {
+        return false;
+    }
+}