@promptctl/rich-js 0.18.0 → 0.19.0

package/dist/core/easing.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Easing and phase: the one vocabulary for "how far along" — every function
+ * here returns progress in [0, 1].
+ *
+ * Two kinds of curve, composed as `ease(phase(t))`:
+ *
+ * - A **phase** turns a time `t` (seconds) into raw progress: `once` runs
+ *   0 → 1 over a span and holds, `loop` wraps 0 → 1 every period,
+ *   `pingPong` goes 0 → 1 → 0 every period. A per-cell offset is added to `t`
+ *   before the phase sees it — `phase(t + offset)` — so the cells of one
+ *   effect run the same curve shifted in time.
+ * - An **ease** reshapes that progress: any `(x) => y` on [0, 1]. The
+ *   built-ins are CSS's easing functions (CSS Easing Functions Level 1):
+ *   `linear`, `cubic-bezier()` with its named curves, and `steps()` with its
+ *   jump terms, plus `sine` for pulses — a half-cosine, so a `pingPong`
+ *   through it brightens and dims with no corner at either end.
+ *
+ * [LAW:no-ambient-temporal-coupling] Nothing here reads a clock. `t` is an
+ * argument; whoever draws frames owns the clock and samples these at
+ * whatever rate it likes, so the same `t` always gives the same progress.
+ *
+ * [LAW:one-type-per-behavior] An ease is a plain function value. CSS's named
+ * curves are four instances of `cubicBezier`, not four implementations, and
+ * `ColorRamp` and every effect take the same `Ease`.
+ *
+ * Tier 0 of `src/core/`: imports nothing, so `themes/` and every later
+ * `core/` module reach it downhill. [LAW:one-way-deps]
+ */
+/** Progress in, progress out: a reshaping of [0, 1]. */
+export type Ease = (x: number) => number;
+/** Time in seconds (plus any per-cell offset) in, progress in [0, 1] out. */
+export type Phase = (t: number) => number;
+/**
+ * CSS `cubic-bezier(x1, y1, x2, y2)`: the curve from (0, 0) to (1, 1) with
+ * those two control points, read as y at a given x. `x1` and `x2` must lie in
+ * [0, 1] — as in CSS — which keeps x monotonic in the curve parameter, so
+ * every input has exactly one output. `y1` and `y2` may leave [0, 1]; the
+ * curve then overshoots, as a CSS "back" curve does.
+ */
+export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): Ease;
+/**
+ * Where a `steps()` curve jumps, in CSS's terms. `jump-start` jumps at 0,
+ * `jump-end` at 1, `jump-both` at both, `jump-none` at neither; `start` and
+ * `end` are CSS's older spellings of the first two.
+ */
+export type StepPosition = "jump-start" | "jump-end" | "jump-none" | "jump-both" | "start" | "end";
+/**
+ * CSS `steps(n, position)`: progress held flat in `n` equal intervals, jumping
+ * between them. The output takes `n` distinct values between the jumps
+ * `position` names — CSS's step algorithm, so `steps(1, "end")` is 0 until
+ * the very end.
+ */
+export declare function steps(n: number, position?: StepPosition): Ease;
+/**
+ * Every built-in ease by the name a template spells it with — CSS's keyword
+ * names, plus `sine`, plus `step`: the spelling `ColorRamp` used before this
+ * vocabulary existed, kept so every template written against it renders the
+ * same. It is CSS's `step-end`, the same function value.
+ */
+export declare const EASES: {
+    readonly linear: Ease;
+    readonly ease: Ease;
+    readonly "ease-in": Ease;
+    readonly "ease-out": Ease;
+    readonly "ease-in-out": Ease;
+    readonly "step-start": Ease;
+    readonly "step-end": Ease;
+    readonly step: Ease;
+    readonly sine: Ease;
+};
+export type EaseName = keyof typeof EASES;
+/**
+ * The gate a spelled ease crosses. [LAW:parse-dont-validate] — a name in, the
+ * function out, so nothing downstream holds a string it must check again.
+ * Unknown names throw naming every legal one. [LAW:no-silent-failure]
+ */
+export declare function parseEase(name: string): Ease;
+/** The three phase shapes. Each takes seconds and returns a `Phase`. */
+export declare const Phase: {
+    /** 0 before `start`, rising to 1 over `duration` seconds, then held at 1. */
+    once(start: number, duration: number): Phase;
+    /** 0 → 1 every `period` seconds, wrapping back to 0; negative `t` wraps too. */
+    loop(period: number): Phase;
+    /** 0 → 1 → 0 every `period` seconds: there in the first half, back in the second. */
+    pingPong(period: number): Phase;
+};

package/dist/core/easing.js

@@ -0,0 +1,171 @@
+/**
+ * Easing and phase: the one vocabulary for "how far along" — every function
+ * here returns progress in [0, 1].
+ *
+ * Two kinds of curve, composed as `ease(phase(t))`:
+ *
+ * - A **phase** turns a time `t` (seconds) into raw progress: `once` runs
+ *   0 → 1 over a span and holds, `loop` wraps 0 → 1 every period,
+ *   `pingPong` goes 0 → 1 → 0 every period. A per-cell offset is added to `t`
+ *   before the phase sees it — `phase(t + offset)` — so the cells of one
+ *   effect run the same curve shifted in time.
+ * - An **ease** reshapes that progress: any `(x) => y` on [0, 1]. The
+ *   built-ins are CSS's easing functions (CSS Easing Functions Level 1):
+ *   `linear`, `cubic-bezier()` with its named curves, and `steps()` with its
+ *   jump terms, plus `sine` for pulses — a half-cosine, so a `pingPong`
+ *   through it brightens and dims with no corner at either end.
+ *
+ * [LAW:no-ambient-temporal-coupling] Nothing here reads a clock. `t` is an
+ * argument; whoever draws frames owns the clock and samples these at
+ * whatever rate it likes, so the same `t` always gives the same progress.
+ *
+ * [LAW:one-type-per-behavior] An ease is a plain function value. CSS's named
+ * curves are four instances of `cubicBezier`, not four implementations, and
+ * `ColorRamp` and every effect take the same `Ease`.
+ *
+ * Tier 0 of `src/core/`: imports nothing, so `themes/` and every later
+ * `core/` module reach it downhill. [LAW:one-way-deps]
+ */
+/**
+ * CSS `cubic-bezier(x1, y1, x2, y2)`: the curve from (0, 0) to (1, 1) with
+ * those two control points, read as y at a given x. `x1` and `x2` must lie in
+ * [0, 1] — as in CSS — which keeps x monotonic in the curve parameter, so
+ * every input has exactly one output. `y1` and `y2` may leave [0, 1]; the
+ * curve then overshoots, as a CSS "back" curve does.
+ */
+export function cubicBezier(x1, y1, x2, y2) {
+    for (const [name, v] of [["x1", x1], ["y1", y1], ["x2", x2], ["y2", y2]]) {
+        if (!Number.isFinite(v))
+            throw new RangeError(`cubicBezier ${name} must be finite, got ${v}`);
+    }
+    if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+        throw new RangeError(`cubicBezier x1 and x2 must lie in [0, 1], got ${x1} and ${x2}`);
+    }
+    // The Bernstein form in power basis: x(s) = ((ax·s + bx)·s + cx)·s, same for y.
+    const cx = 3 * x1;
+    const bx = 3 * (x2 - x1) - cx;
+    const ax = 1 - cx - bx;
+    const cy = 3 * y1;
+    const by = 3 * (y2 - y1) - cy;
+    const ay = 1 - cy - by;
+    const xAt = (s) => ((ax * s + bx) * s + cx) * s;
+    const yAt = (s) => ((ay * s + by) * s + cy) * s;
+    const dxAt = (s) => (3 * ax * s + 2 * bx) * s + cx;
+    const EPSILON = 1e-9;
+    // The parameter s with x(s) = x: Newton's method from s = x, which converges
+    // in a few steps on every curve CSS names; bisection when the slope is too
+    // flat for Newton to trust. x(s) is monotonic on [0, 1], so bisection always
+    // lands.
+    const solve = (x) => {
+        let s = x;
+        for (let i = 0; i < 8; i++) {
+            const err = xAt(s) - x;
+            if (Math.abs(err) < EPSILON)
+                return s;
+            const slope = dxAt(s);
+            if (Math.abs(slope) < 1e-6)
+                break;
+            s -= err / slope;
+        }
+        let lo = 0;
+        let hi = 1;
+        s = x;
+        while (hi - lo > EPSILON) {
+            if (xAt(s) < x)
+                lo = s;
+            else
+                hi = s;
+            s = (lo + hi) / 2;
+        }
+        return s;
+    };
+    return (x) => yAt(solve(Math.min(1, Math.max(0, x))));
+}
+/**
+ * CSS `steps(n, position)`: progress held flat in `n` equal intervals, jumping
+ * between them. The output takes `n` distinct values between the jumps
+ * `position` names — CSS's step algorithm, so `steps(1, "end")` is 0 until
+ * the very end.
+ */
+export function steps(n, position = "jump-end") {
+    const minimum = position === "jump-none" ? 2 : 1;
+    if (!Number.isInteger(n) || n < minimum) {
+        throw new RangeError(`steps(${n}, "${position}") needs a whole number of steps ≥ ${minimum}`);
+    }
+    const jumpsAtStart = position === "jump-start" || position === "start" || position === "jump-both";
+    // How many jumps the curve makes in all, which is what each step is a fraction of.
+    const jumps = {
+        "jump-start": n,
+        start: n,
+        "jump-end": n,
+        end: n,
+        "jump-both": n + 1,
+        "jump-none": n - 1,
+    }[position];
+    const lift = jumpsAtStart ? 1 : 0;
+    return (x) => {
+        const p = Math.min(1, Math.max(0, x));
+        return Math.min(jumps, Math.floor(p * n) + lift) / jumps;
+    };
+}
+/** The identity ease: progress unchanged. */
+const linear = (x) => x;
+/** CSS `step-end`: 0 until the very end. */
+const stepEnd = steps(1, "jump-end");
+/** A half-cosine, flat at both ends: the curve a breathing pulse wants. */
+const sine = (x) => (1 - Math.cos(Math.PI * x)) / 2;
+/**
+ * Every built-in ease by the name a template spells it with — CSS's keyword
+ * names, plus `sine`, plus `step`: the spelling `ColorRamp` used before this
+ * vocabulary existed, kept so every template written against it renders the
+ * same. It is CSS's `step-end`, the same function value.
+ */
+export const EASES = {
+    linear,
+    ease: cubicBezier(0.25, 0.1, 0.25, 1),
+    "ease-in": cubicBezier(0.42, 0, 1, 1),
+    "ease-out": cubicBezier(0, 0, 0.58, 1),
+    "ease-in-out": cubicBezier(0.42, 0, 0.58, 1),
+    "step-start": steps(1, "jump-start"),
+    "step-end": stepEnd,
+    step: stepEnd,
+    sine,
+};
+/**
+ * The gate a spelled ease crosses. [LAW:parse-dont-validate] — a name in, the
+ * function out, so nothing downstream holds a string it must check again.
+ * Unknown names throw naming every legal one. [LAW:no-silent-failure]
+ */
+export function parseEase(name) {
+    if (!Object.hasOwn(EASES, name)) {
+        throw new RangeError(`unknown ease ${JSON.stringify(name)}; expected one of ` +
+            Object.keys(EASES).map((n) => JSON.stringify(n)).join(", "));
+    }
+    return EASES[name];
+}
+function positiveSeconds(what, seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new RangeError(`${what} must be a positive number of seconds, got ${seconds}`);
+    }
+}
+/** The three phase shapes. Each takes seconds and returns a `Phase`. */
+export const Phase = {
+    /** 0 before `start`, rising to 1 over `duration` seconds, then held at 1. */
+    once(start, duration) {
+        if (!Number.isFinite(start))
+            throw new RangeError(`Phase.once start must be finite, got ${start}`);
+        positiveSeconds("Phase.once duration", duration);
+        return (t) => Math.min(1, Math.max(0, (t - start) / duration));
+    },
+    /** 0 → 1 every `period` seconds, wrapping back to 0; negative `t` wraps too. */
+    loop(period) {
+        positiveSeconds("Phase.loop period", period);
+        return (t) => (((t % period) + period) % period) / period;
+    },
+    /** 0 → 1 → 0 every `period` seconds: there in the first half, back in the second. */
+    pingPong(period) {
+        positiveSeconds("Phase.pingPong period", period);
+        const wrap = Phase.loop(period);
+        return (t) => 1 - Math.abs(2 * wrap(t) - 1);
+    },
+};

package/dist/core/emoji.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Emoji shortcode support — dictionary, replacement, and renderable.
+ */
+import { Segment } from "./segment.js";
+import type { Style } from "./style.js";
+import type { Renderable, RenderOptions } from "./protocol.js";
+export declare const EMOJI: Record<string, string>;
+/**
+ * Replaces :shortcode: patterns in text with emoji characters.
+ */
+export declare function emojiReplace(text: string, defaultVariant?: "emoji" | "text"): string;
+export declare class NoEmoji extends Error {
+    constructor(name: string);
+}
+export declare class Emoji implements Renderable {
+    readonly name: string;
+    private readonly _char;
+    private readonly _style;
+    private readonly _variant;
+    constructor(name: string, style?: Style, variant?: "emoji" | "text");
+    toString(): string;
+    render(_options: RenderOptions): Iterable<Segment>;
+    static replace(text: string): string;
+}

package/dist/core/emoji.js

@@ -0,0 +1,391 @@
+/**
+ * Emoji shortcode support — dictionary, replacement, and renderable.
+ */
+import { Segment } from "./segment.js";
+// [LAW:one-source-of-truth] Single emoji dictionary for all shortcode lookups
+export const EMOJI = {
+    // Faces
+    smile: "😄",
+    laugh: "😂",
+    grinning: "😀",
+    wink: "😉",
+    blush: "😊",
+    innocent: "😇",
+    heart_eyes: "😍",
+    kissing: "😘",
+    thinking: "🤔",
+    shushing: "🤫",
+    zipper_mouth: "🤐",
+    raised_eyebrow: "🤨",
+    neutral: "😐",
+    expressionless: "😑",
+    unamused: "😒",
+    rolling_eyes: "🙄",
+    grimacing: "😬",
+    lying: "🤥",
+    relieved: "😌",
+    pensive: "😔",
+    sleepy: "😪",
+    sleeping: "😴",
+    mask: "😷",
+    thermometer_face: "🤒",
+    bandage_face: "🤕",
+    nauseated: "🤢",
+    sneezing: "🤧",
+    cold_face: "🥶",
+    hot_face: "🥵",
+    dizzy_face: "😵",
+    exploding_head: "🤯",
+    cowboy: "🤠",
+    party_face: "🥳",
+    sunglasses: "😎",
+    nerd: "🤓",
+    monocle: "🧐",
+    confused: "😕",
+    worried: "😟",
+    frowning: "☹",
+    open_mouth: "😮",
+    hushed: "😯",
+    astonished: "😲",
+    flushed: "😳",
+    pleading: "🥺",
+    cry: "😢",
+    sob: "😭",
+    scream: "😱",
+    sweat: "😰",
+    angry: "😡",
+    rage: "🤬",
+    devil: "😈",
+    skull: "💀",
+    poop: "💩",
+    clown: "🤡",
+    ghost: "👻",
+    alien: "👽",
+    robot: "🤖",
+    // Hands
+    wave: "👋",
+    raised_hand: "✋",
+    ok_hand: "👌",
+    pinching: "🤏",
+    victory: "✌",
+    crossed_fingers: "🤞",
+    love_you: "🤟",
+    rock_on: "🤘",
+    thumbs_up: "👍",
+    thumbs_down: "👎",
+    fist: "✊",
+    punch: "👊",
+    left_fist: "🤛",
+    right_fist: "🤜",
+    clap: "👏",
+    raised_hands: "🙌",
+    open_hands: "👐",
+    palms_up: "🤲",
+    handshake: "🤝",
+    pray: "🙏",
+    writing_hand: "✍",
+    nail_polish: "💅",
+    muscle: "💪",
+    point_up: "☝",
+    point_up_2: "👆",
+    point_down: "👇",
+    point_left: "👈",
+    point_right: "👉",
+    middle_finger: "🖕",
+    // Hearts
+    heart: "❤",
+    orange_heart: "🧡",
+    yellow_heart: "💛",
+    green_heart: "💚",
+    blue_heart: "💙",
+    purple_heart: "💜",
+    black_heart: "🖤",
+    white_heart: "🤍",
+    brown_heart: "🤎",
+    broken_heart: "💔",
+    heart_exclamation: "❣",
+    two_hearts: "💕",
+    revolving_hearts: "💞",
+    heartbeat: "💓",
+    heartpulse: "💗",
+    sparkling_heart: "💖",
+    growing_heart: "💗",
+    cupid: "💘",
+    gift_heart: "💝",
+    // Objects & Symbols
+    fire: "🔥",
+    star: "⭐",
+    star2: "🌟",
+    sparkles: "✨",
+    zap: "⚡",
+    boom: "💥",
+    droplet: "💧",
+    rainbow: "🌈",
+    sun: "☀",
+    moon: "🌙",
+    cloud: "☁",
+    snowflake: "❄",
+    umbrella: "☂",
+    // Status
+    check: "✅",
+    check_mark: "✔",
+    cross_mark: "❌",
+    warning: "⚠",
+    info: "ℹ",
+    question: "❓",
+    exclamation: "❗",
+    no_entry: "⛔",
+    prohibited: "🚫",
+    stop_sign: "🛑",
+    // Arrows
+    arrow_up: "⬆",
+    arrow_down: "⬇",
+    arrow_left: "⬅",
+    arrow_right: "➡",
+    arrow_upper_left: "↖",
+    arrow_upper_right: "↗",
+    arrow_lower_left: "↙",
+    arrow_lower_right: "↘",
+    left_right_arrow: "↔",
+    up_down_arrow: "↕",
+    arrows_clockwise: "🔃",
+    arrows_counterclockwise: "🔄",
+    // Tech
+    computer: "💻",
+    keyboard: "⌨",
+    desktop: "🖥",
+    printer: "🖨",
+    mouse: "🖱",
+    cd: "💿",
+    dvd: "📀",
+    floppy: "💾",
+    battery: "🔋",
+    plug: "🔌",
+    bulb: "💡",
+    flashlight: "🔦",
+    gear: "⚙",
+    wrench: "🔧",
+    hammer: "🔨",
+    nut_and_bolt: "🔩",
+    link: "🔗",
+    chains: "⛓",
+    lock: "🔒",
+    unlock: "🔓",
+    key: "🔑",
+    shield: "🛡",
+    bug: "🐛",
+    magnifying_glass: "🔍",
+    // Communication
+    speech_balloon: "💬",
+    thought_balloon: "💭",
+    megaphone: "📣",
+    loudspeaker: "📢",
+    bell: "🔔",
+    no_bell: "🔕",
+    envelope: "✉",
+    email: "📧",
+    inbox: "📥",
+    outbox: "📤",
+    package: "📦",
+    clipboard: "📋",
+    memo: "📝",
+    page: "📄",
+    bookmark: "🔖",
+    label: "🏷",
+    // Time
+    hourglass: "⌛",
+    hourglass_flowing: "⏳",
+    watch: "⌚",
+    alarm_clock: "⏰",
+    stopwatch: "⏱",
+    timer: "⏲",
+    clock: "🕐",
+    // Numbers
+    zero: "0️⃣",
+    one: "1️⃣",
+    two: "2️⃣",
+    three: "3️⃣",
+    four: "4️⃣",
+    five: "5️⃣",
+    six: "6️⃣",
+    seven: "7️⃣",
+    eight: "8️⃣",
+    nine: "9️⃣",
+    ten: "🔟",
+    hash: "#️⃣",
+    // Food & Drink
+    coffee: "☕",
+    tea: "🍵",
+    beer: "🍺",
+    wine: "🍷",
+    cocktail: "🍸",
+    pizza: "🍕",
+    hamburger: "🍔",
+    fries: "🍟",
+    hotdog: "🌭",
+    taco: "🌮",
+    cake: "🎂",
+    cookie: "🍪",
+    chocolate: "🍫",
+    candy: "🍬",
+    apple: "🍎",
+    banana: "🍌",
+    // Nature & Animals
+    dog: "🐕",
+    cat: "🐈",
+    snake: "🐍",
+    turtle: "🐢",
+    whale: "🐳",
+    dolphin: "🐬",
+    fish: "🐟",
+    butterfly: "🦋",
+    bee: "🐝",
+    ladybug: "🐞",
+    spider: "🕷",
+    tree: "🌲",
+    flower: "🌸",
+    rose: "🌹",
+    sunflower: "🌻",
+    cactus: "🌵",
+    // Activities
+    trophy: "🏆",
+    medal: "🏅",
+    crown: "👑",
+    gem: "💎",
+    money_bag: "💰",
+    dollar: "💵",
+    rocket: "🚀",
+    airplane: "✈",
+    car: "🚗",
+    bicycle: "🚲",
+    house: "🏠",
+    building: "🏢",
+    globe: "🌍",
+    world_map: "🗺",
+    flag: "🏁",
+    party: "🎉",
+    confetti: "🎊",
+    balloon: "🎈",
+    gift: "🎁",
+    art: "🎨",
+    music: "🎵",
+    notes: "🎶",
+    microphone: "🎤",
+    headphones: "🎧",
+    movie: "🎬",
+    camera: "📷",
+    book: "📖",
+    books: "📚",
+    scroll: "📜",
+    newspaper: "📰",
+    // People
+    person: "🧑",
+    man: "👨",
+    woman: "👩",
+    child: "🧒",
+    baby: "👶",
+    eyes: "👀",
+    eye: "👁",
+    brain: "🧠",
+    tongue: "👅",
+    ear: "👂",
+    nose: "👃",
+    foot: "🦶",
+    hand: "🤚",
+    // Misc
+    red_circle: "🔴",
+    orange_circle: "🟠",
+    yellow_circle: "🟡",
+    green_circle: "🟢",
+    blue_circle: "🔵",
+    purple_circle: "🟣",
+    black_circle: "⚫",
+    white_circle: "⚪",
+    red_square: "🟥",
+    orange_square: "🟧",
+    yellow_square: "🟨",
+    green_square: "🟩",
+    blue_square: "🟦",
+    purple_square: "🟪",
+    black_square: "⬛",
+    white_square: "⬜",
+    checkered_flag: "🏁",
+    triangular_flag: "🚩",
+    crossed_flags: "🎌",
+    pirate_flag: "🏴‍☠️",
+    white_flag: "🏳",
+    100: "💯",
+    infinity: "♾",
+    recycle: "♻",
+    peace: "☮",
+    yin_yang: "☯",
+    cross: "✝",
+    atom: "⚛",
+    radioactive: "☢",
+    biohazard: "☣",
+};
+const EMOJI_PATTERN = /:([a-z0-9_]+(?:-(?:emoji|text))?):/g;
+/**
+ * Replaces :shortcode: patterns in text with emoji characters.
+ */
+export function emojiReplace(text, defaultVariant) {
+    return text.replace(EMOJI_PATTERN, (_match, code) => {
+        let variant = defaultVariant;
+        let name = code;
+        // Check for inline variant suffix
+        if (name.endsWith("-emoji")) {
+            variant = "emoji";
+            name = name.slice(0, -6);
+        }
+        else if (name.endsWith("-text")) {
+            variant = "text";
+            name = name.slice(0, -5);
+        }
+        const emoji = EMOJI[name];
+        if (emoji === undefined)
+            return _match; // Not found, leave unchanged
+        // Apply variant selector
+        // [LAW:dataflow-not-control-flow] Always compute suffix, let the value decide
+        const suffix = variant === "emoji"
+            ? "\uFE0F"
+            : variant === "text"
+                ? "\uFE0E"
+                : "";
+        return emoji + suffix;
+    });
+}
+export class NoEmoji extends Error {
+    constructor(name) {
+        super(`No emoji with name: "${name}"`);
+        this.name = "NoEmoji";
+    }
+}
+export class Emoji {
+    name;
+    _char;
+    _style;
+    _variant;
+    constructor(name, style, variant) {
+        const emoji = EMOJI[name];
+        if (emoji === undefined)
+            throw new NoEmoji(name);
+        this.name = name;
+        this._char = emoji;
+        this._style = style;
+        this._variant = variant;
+    }
+    toString() {
+        const suffix = this._variant === "emoji"
+            ? "\uFE0F"
+            : this._variant === "text"
+                ? "\uFE0E"
+                : "";
+        return this._char + suffix;
+    }
+    *render(_options) {
+        yield new Segment(this.toString(), this._style);
+    }
+    static replace(text) {
+        return emojiReplace(text);
+    }
+}

package/dist/core/env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Env — the environment variables a program running on a terminal sees, as
+ * every public type that carries them names it.
+ *
+ * [LAW:types-are-the-program] The strongest true theorem about what this
+ * library does with an environment is "reads a variable by name, which may be
+ * unset." It never writes one, and it never touches the rest of node's
+ * `NodeJS.ProcessEnv`. Node's `process.env` satisfies this as-is, and so does
+ * a frozen literal in a browser, where there is no `process` at all.
+ *
+ * It lives here rather than being spelled `NodeJS.ProcessEnv` because a public
+ * signature is emitted into the `.d.ts` verbatim, and a TypeScript project
+ * without `@types/node` — the ordinary browser project — cannot resolve the
+ * `NodeJS` namespace. `test/seam/browser-types.test.ts` holds that line.
+ */
+export type Env = Readonly<Record<string, string | undefined>>;