# Text Scramble

Teks yang teracak menjadi karakter acak, lalu terdekripsi huruf demi huruf. Berjalan saat hover, saat masuk layar, atau saat dimuat.

- Kategori: Animasi
- Status: stable
- Registry: https://markas.jenderalcorp.com/r/text-scramble.json
- CLI: `npx markasui@latest add text-scramble`

## Kapan dipakai

Angka statistik yang terdekripsi saat masuk layar, judul bernuansa teknologi, dan link yang berkedip acak saat hover.

- Pakai charset digits untuk angka dan harga
- Pakai trigger view dengan delay bertingkat untuk deretan statistik
- Pakai teks pendek; paragraf panjang sulit dibaca saat teracak
- Blade butuh Alpine.js

## Kode

### Blade

Simpan di `resources/views/components/markas/text-scramble.blade.php`. Dependensi: alpinejs.

```blade
@props([
    'text' => '',
    'trigger' => 'hover',
    'charset' => 'letters',
    'duration' => 800,
    'delay' => 0,
])

@php
    $root = 'inline-grid tabular-nums';
    $layer = 'col-start-1 row-start-1';
    $holder = 'invisible col-start-1 row-start-1';

    $charsets = [
        'letters' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
        'digits' => '0123456789',
        'symbols' => '!@$%&*+=<>/?{}[]',
        'binary' => '01',
    ];
@endphp

<span
    x-data="{
        text: @js((string) $text),
        display: @js((string) $text),
        frame: 0,
        observer: null,
        cleanup: () => {},
        {{-- Acak deterministik (Park-Miller): urutan huruf acak sama di setiap putaran dan framework. --}}
        scrambler() {
            const chars = Array.from(this.text);
            const set = @js($charsets[$charset] ?? $charsets['letters']);
            let seed = 1;
            const pick = () => {
                seed = (seed * 48271) % 2147483647;
                return set[seed % set.length];
            };
            return (revealed) => chars.map((char, i) => (i < revealed || char.trim() === '' ? char : pick())).join('');
        },
        {{-- Acak semua huruf, lalu buka dari kiri ke kanan sampai teks asli kembali utuh. Huruf berganti paling cepat setiap 50 ms. --}}
        run(wait) {
            if (this.frame) return;
            const scramble = this.scrambler();
            const total = Array.from(this.text).length;
            const duration = @js((int) $duration);
            let began;
            let last = -50;
            const tick = (now) => {
                began ??= now;
                const progress = Math.min((now - began - wait) / duration, 1);
                if (now - last >= 50 || progress >= 1) {
                    last = now;
                    this.display = scramble(Math.max(Math.floor(progress * total), 0));
                }
                this.frame = progress < 1 ? requestAnimationFrame(tick) : 0;
            };
            this.frame = requestAnimationFrame(tick);
        },
        init() {
            if (window.matchMedia?.('(prefers-reduced-motion: reduce)').matches) return;
            const trigger = @js($trigger);
            const delay = @js((int) $delay);
            {{-- Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. --}}
            if (trigger === 'hover') {
                const target = this.$el.closest('a, button, label, [tabindex]') ?? this.$el;
                const hover = () => this.run(0);
                target.addEventListener('pointerenter', hover);
                target.addEventListener('focusin', hover);
                this.cleanup = () => {
                    target.removeEventListener('pointerenter', hover);
                    target.removeEventListener('focusin', hover);
                };
                return;
            }
            this.display = this.scrambler()(0);
            if (trigger === 'mount' || typeof IntersectionObserver === 'undefined') return this.run(delay);
            this.observer = new IntersectionObserver((entries) => {
                if (! entries.some((entry) => entry.isIntersecting)) return;
                this.observer.disconnect();
                this.run(delay);
            });
            this.observer.observe(this.$el);
        },
        destroy() {
            this.observer?.disconnect();
            cancelAnimationFrame(this.frame);
            this.cleanup();
        },
    }"
    {{ $attributes->class([$root]) }}
><span class="sr-only">{{ $text }}</span><span aria-hidden="true" class="{{ $holder }}">{{ $text }}</span><span aria-hidden="true" class="{{ $layer }}" x-text="display">{{ $text }}</span></span>
```

```blade
<h2 class="text-3xl font-semibold">
    <x-markas.text-scramble text="Operasi Nusantara" trigger="view" />
</h2>
<x-markas.text-scramble text="Rp 12,4 M" trigger="view" charset="digits" />
<x-markas.text-scramble text="99.98%" trigger="view" charset="digits" :delay="150" />
<a href="/brief"><x-markas.text-scramble text="Buka brief" charset="symbols" /></a>
```

### React

Simpan di `src/components/markas/TextScramble.tsx`. Tanpa dependensi tambahan.

```tsx
"use client";

import { useEffect, useRef, useState, type ComponentProps } from "react";

const root = "inline-grid tabular-nums";
const layer = "col-start-1 row-start-1";
const holder = "invisible col-start-1 row-start-1";

const charsets = {
  letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  digits: "0123456789",
  symbols: "!@$%&*+=<>/?{}[]",
  binary: "01",
};

/** Huruf acak diganti paling cepat setiap 50 ms supaya tetap terbaca sebagai efek, bukan kedipan. */
const FRAME = 50;
/** Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. */
const TRIGGER = "a, button, label, [tabindex]";

const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Acak deterministik (Park-Miller): urutan huruf acak sama di setiap putaran dan framework. */
function scrambler(text: string, charset: string) {
  const chars = Array.from(text);
  let seed = 1;
  const pick = () => {
    seed = (seed * 48271) % 2147483647;
    return charset[seed % charset.length];
  };
  return (revealed: number) =>
    chars
      .map((char, i) => (i < revealed || char.trim() === "" ? char : pick()))
      .join("");
}

export type TextScrambleProps = Omit<ComponentProps<"span">, "children"> & {
  text: string;
  trigger?: "hover" | "view" | "mount";
  charset?: keyof typeof charsets;
  duration?: number;
  delay?: number;
};

export function TextScramble({
  text,
  trigger = "hover",
  charset = "letters",
  duration = 800,
  delay = 0,
  className,
  ...props
}: TextScrambleProps) {
  const rootRef = useRef<HTMLSpanElement>(null);
  // Teks acak disimpan bersama sumbernya; kalau text berubah, teks asli langsung tampil lagi.
  const [frame, setFrame] = useState({ source: "", value: "" });
  const display = frame.source === text ? frame.value : text;

  useEffect(() => {
    const element = rootRef.current;
    if (!element || reducedMotion()) return;
    const set = charsets[charset];
    const total = Array.from(text).length;
    let frame = 0;
    let observer: IntersectionObserver | undefined;

    // Acak semua huruf, lalu buka dari kiri ke kanan sampai teks asli kembali utuh.
    const run = (wait: number) => {
      if (frame) return;
      const scramble = scrambler(text, set);
      let began: number | undefined;
      let last = -FRAME;
      const tick = (now: number) => {
        began ??= now;
        const progress = Math.min((now - began - wait) / duration, 1);
        if (now - last >= FRAME || progress >= 1) {
          last = now;
          const revealed = Math.max(Math.floor(progress * total), 0);
          setFrame({ source: text, value: scramble(revealed) });
        }
        frame = progress < 1 ? requestAnimationFrame(tick) : 0;
      };
      frame = requestAnimationFrame(tick);
    };

    const target = element.closest<HTMLElement>(TRIGGER) ?? element;
    const hover = () => run(0);
    if (trigger === "hover") {
      target.addEventListener("pointerenter", hover);
      target.addEventListener("focusin", hover);
    } else {
      if (trigger === "mount" || typeof IntersectionObserver === "undefined")
        run(delay);
      else {
        // Di luar layar teks sudah teracak, lalu terdekripsi sekali saat terlihat.
        observer = new IntersectionObserver((entries) => {
          if (!entries.some((entry) => entry.isIntersecting))
            return setFrame({ source: text, value: scrambler(text, set)(0) });
          observer?.disconnect();
          run(delay);
        });
        observer.observe(element);
      }
    }
    return () => {
      observer?.disconnect();
      cancelAnimationFrame(frame);
      target.removeEventListener("pointerenter", hover);
      target.removeEventListener("focusin", hover);
    };
  }, [text, trigger, charset, duration, delay]);

  return (
    <span ref={rootRef} {...props} className={cx(root, className)}>
      <span className="sr-only">{text}</span>
      <span aria-hidden="true" className={holder}>
        {text}
      </span>
      <span aria-hidden="true" className={layer}>
        {display}
      </span>
    </span>
  );
}
```

```tsx
import { TextScramble } from "@/components/markas/TextScramble";

<h2 className="text-3xl font-semibold">
  <TextScramble text="Operasi Nusantara" trigger="view" />
</h2>
<TextScramble text="Rp 12,4 M" trigger="view" charset="digits" />
<TextScramble text="99.98%" trigger="view" charset="digits" delay={150} />
<a href="/brief"><TextScramble text="Buka brief" charset="symbols" /></a>
```

### Vue

Simpan di `src/components/markas/TextScramble.vue`. Tanpa dependensi tambahan.

```vue
<script setup lang="ts">
import { onBeforeUnmount, onMounted, ref, useTemplateRef, watch } from "vue";

const props = withDefaults(
  defineProps<{
    text: string;
    trigger?: "hover" | "view" | "mount";
    charset?: "letters" | "digits" | "symbols" | "binary";
    duration?: number;
    delay?: number;
  }>(),
  { trigger: "hover", charset: "letters", duration: 800, delay: 0 },
);

const root = "inline-grid tabular-nums";
const layer = "col-start-1 row-start-1";
const holder = "invisible col-start-1 row-start-1";

const charsets = {
  letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  digits: "0123456789",
  symbols: "!@$%&*+=<>/?{}[]",
  binary: "01",
};

/** Huruf acak diganti paling cepat setiap 50 ms supaya tetap terbaca sebagai efek, bukan kedipan. */
const FRAME = 50;
/** Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. */
const TRIGGER = "a, button, label, [tabindex]";

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Acak deterministik (Park-Miller): urutan huruf acak sama di setiap putaran dan framework. */
function scrambler(text: string, charset: string) {
  const chars = Array.from(text);
  let seed = 1;
  const pick = () => {
    seed = (seed * 48271) % 2147483647;
    return charset[seed % charset.length];
  };
  return (revealed: number) =>
    chars
      .map((char, i) => (i < revealed || char.trim() === "" ? char : pick()))
      .join("");
}

const rootEl = useTemplateRef<HTMLSpanElement>("rootRef");
const display = ref(props.text);
let cleanup = () => {};

function start() {
  cleanup();
  const { text, trigger, duration, delay } = props;
  const element = rootEl.value;
  display.value = text;
  if (!element || reducedMotion()) return;
  const set = charsets[props.charset];
  const total = Array.from(text).length;
  let frame = 0;
  let observer: IntersectionObserver | undefined;

  // Acak semua huruf, lalu buka dari kiri ke kanan sampai teks asli kembali utuh.
  const run = (wait: number) => {
    if (frame) return;
    const scramble = scrambler(text, set);
    let began: number | undefined;
    let last = -FRAME;
    const tick = (now: number) => {
      began ??= now;
      const progress = Math.min((now - began - wait) / duration, 1);
      if (now - last >= FRAME || progress >= 1) {
        last = now;
        display.value = scramble(Math.max(Math.floor(progress * total), 0));
      }
      frame = progress < 1 ? requestAnimationFrame(tick) : 0;
    };
    frame = requestAnimationFrame(tick);
  };

  const target = element.closest<HTMLElement>(TRIGGER) ?? element;
  const hover = () => run(0);
  if (trigger === "hover") {
    target.addEventListener("pointerenter", hover);
    target.addEventListener("focusin", hover);
  } else {
    display.value = scrambler(text, set)(0);
    if (trigger === "mount" || typeof IntersectionObserver === "undefined")
      run(delay);
    else {
      observer = new IntersectionObserver((entries) => {
        if (!entries.some((entry) => entry.isIntersecting)) return;
        observer?.disconnect();
        run(delay);
      });
      observer.observe(element);
    }
  }
  cleanup = () => {
    observer?.disconnect();
    cancelAnimationFrame(frame);
    target.removeEventListener("pointerenter", hover);
    target.removeEventListener("focusin", hover);
  };
}

onMounted(start);
watch(
  () => [props.text, props.trigger, props.charset, props.duration, props.delay],
  start,
  { flush: "post" },
);
onBeforeUnmount(() => cleanup());
</script>

<template>
  <span ref="rootRef" :class="root"
    ><span class="sr-only">{{ props.text }}</span
    ><span aria-hidden="true" :class="holder">{{ props.text }}</span
    ><span aria-hidden="true" :class="layer">{{ display }}</span></span
  >
</template>
```

```vue
<template>
  <h2 class="text-3xl font-semibold">
    <TextScramble text="Operasi Nusantara" trigger="view" />
  </h2>
  <TextScramble text="Rp 12,4 M" trigger="view" charset="digits" />
  <TextScramble text="99.98%" trigger="view" charset="digits" :delay="150" />
  <a href="/brief"><TextScramble text="Buka brief" charset="symbols" /></a>
</template>
```

### Svelte

Simpan di `src/lib/components/markas/TextScramble.svelte`. Tanpa dependensi tambahan.

```svelte
<script lang="ts">
  import type { HTMLAttributes } from "svelte/elements";

  const root = "inline-grid tabular-nums";
  const layer = "col-start-1 row-start-1";
  const holder = "invisible col-start-1 row-start-1";

  const charsets = {
    letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
    digits: "0123456789",
    symbols: "!@$%&*+=<>/?{}[]",
    binary: "01",
  };

  /** Random letters change at most every 50 ms, so it reads as an effect, not a flicker. */
  const FRAME = 50;
  /** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
  const TRIGGER = "a, button, label, [tabindex]";

  const reducedMotion = () =>
    typeof matchMedia === "function" &&
    matchMedia("(prefers-reduced-motion: reduce)").matches;

  /** Deterministic random (Park-Miller): the same scrambled letters on every run and in every framework. */
  function scrambler(text: string, charset: string) {
    const chars = Array.from(text);
    let seed = 1;
    const pick = () => {
      seed = (seed * 48271) % 2147483647;
      return charset[seed % charset.length];
    };
    return (revealed: number) =>
      chars
        .map((char, i) => (i < revealed || char.trim() === "" ? char : pick()))
        .join("");
  }

  type Props = Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
    text: string;
    trigger?: "hover" | "view" | "mount";
    charset?: keyof typeof charsets;
    duration?: number;
    delay?: number;
  };

  let {
    text,
    trigger = "hover",
    charset = "letters",
    duration = 800,
    delay = 0,
    class: className,
    ...rest
  }: Props = $props();

  let element = $state<HTMLSpanElement>();
  // The visible text while scrambling; the real text otherwise.
  let display = $state<string>();

  $effect(() => {
    // Read every prop up front so the effect reruns when one changes.
    const options = { text, trigger, duration, delay };
    const set = charsets[charset];
    display = undefined;
    if (!element || reducedMotion()) return;
    const total = Array.from(options.text).length;
    let frame = 0;
    let observer: IntersectionObserver | undefined;

    // Scramble every letter, then reveal from left to right until the real text is whole again.
    const run = (wait: number) => {
      if (frame) return;
      const scramble = scrambler(options.text, set);
      let began: number | undefined;
      let last = -FRAME;
      const tick = (now: number) => {
        began ??= now;
        const progress = Math.min((now - began - wait) / options.duration, 1);
        if (now - last >= FRAME || progress >= 1) {
          last = now;
          display = scramble(Math.max(Math.floor(progress * total), 0));
        }
        frame = progress < 1 ? requestAnimationFrame(tick) : 0;
      };
      frame = requestAnimationFrame(tick);
    };

    const target = element.closest<HTMLElement>(TRIGGER) ?? element;
    const hover = () => run(0);
    if (options.trigger === "hover") {
      target.addEventListener("pointerenter", hover);
      target.addEventListener("focusin", hover);
    } else {
      display = scrambler(options.text, set)(0);
      if (
        options.trigger === "mount" ||
        typeof IntersectionObserver === "undefined"
      )
        run(options.delay);
      else {
        // Scrambled while off screen, then decoded once when it scrolls into view.
        observer = new IntersectionObserver((entries) => {
          if (!entries.some((entry) => entry.isIntersecting)) return;
          observer?.disconnect();
          run(options.delay);
        });
        observer.observe(element);
      }
    }
    return () => {
      observer?.disconnect();
      cancelAnimationFrame(frame);
      target.removeEventListener("pointerenter", hover);
      target.removeEventListener("focusin", hover);
    };
  });
</script>

<span bind:this={element} {...rest} class={[root, className]}
  ><span class="sr-only">{text}</span><span aria-hidden="true" class={holder}
    >{text}</span
  ><span aria-hidden="true" class={layer}>{display ?? text}</span></span
>
```

```svelte
<script lang="ts">
  import TextScramble from "$lib/components/markas/TextScramble.svelte";
</script>

<h2 class="text-3xl font-semibold">
  <TextScramble text="Operasi Nusantara" trigger="view" />
</h2>
<TextScramble text="99.98%" trigger="view" charset="digits" delay={150} />
<a href="/brief"><TextScramble text="Buka brief" charset="symbols" /></a>
```

### Astro

Simpan di `src/components/markas/TextScramble.astro`. Tanpa dependensi tambahan.

```astro
---
import type { HTMLAttributes } from "astro/types";

const root = "inline-grid tabular-nums";
const layer = "col-start-1 row-start-1";
const holder = "invisible col-start-1 row-start-1";

const charsets = {
  letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  digits: "0123456789",
  symbols: "!@$%&*+=<>/?{}[]",
  binary: "01",
};

type Props = Omit<HTMLAttributes<"span">, "children"> & {
  text: string;
  trigger?: "hover" | "view" | "mount";
  charset?: keyof typeof charsets;
  duration?: number;
  delay?: number;
};

const {
  text,
  trigger = "hover",
  charset = "letters",
  duration = 800,
  delay = 0,
  class: className,
  ...rest
} = Astro.props;
---

<markas-text-scramble class="contents" data-trigger={trigger} data-charset={charsets[charset]} data-duration={duration} data-delay={delay}><span {...rest} class:list={[root, className]}><span class="sr-only">{text}</span><span aria-hidden="true" class={holder}>{text}</span><span aria-hidden="true" class={layer}>{text}</span></span></markas-text-scramble>

<script>
  /** Random letters change at most every 50 ms, so it reads as an effect, not a flicker. */
  const FRAME = 50;
  /** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
  const TRIGGER = "a, button, label, [tabindex]";

  /** Deterministic random (Park-Miller): the same scrambled letters on every run and in every framework. */
  function scrambler(text: string, charset: string) {
    const chars = Array.from(text);
    let seed = 1;
    const pick = () => {
      seed = (seed * 48271) % 2147483647;
      return charset[seed % charset.length];
    };
    return (revealed: number) =>
      chars
        .map((char, i) => (i < revealed || char.trim() === "" ? char : pick()))
        .join("");
  }

  // One element per instance: setup runs for markup added later and after view transitions.
  class MarkasTextScramble extends HTMLElement {
    private cleanup = () => {};

    connectedCallback() {
      const element = this.firstElementChild as HTMLElement | null;
      const output = element?.lastElementChild;
      if (!element || !output) return;
      if (matchMedia("(prefers-reduced-motion: reduce)").matches) return;
      const text = element.firstElementChild?.textContent ?? "";
      const set = this.dataset.charset ?? "";
      const duration = Number(this.dataset.duration);
      const delay = Number(this.dataset.delay);
      const total = Array.from(text).length;
      let frame = 0;
      let observer: IntersectionObserver | undefined;

      // Scramble every letter, then reveal from left to right until the real text is whole again.
      const run = (wait: number) => {
        if (frame) return;
        const scramble = scrambler(text, set);
        let began: number | undefined;
        let last = -FRAME;
        const tick = (now: number) => {
          began ??= now;
          const progress = Math.min((now - began - wait) / duration, 1);
          if (now - last >= FRAME || progress >= 1) {
            last = now;
            output.textContent = scramble(
              Math.max(Math.floor(progress * total), 0),
            );
          }
          frame = progress < 1 ? requestAnimationFrame(tick) : 0;
        };
        frame = requestAnimationFrame(tick);
      };

      const target = element.closest<HTMLElement>(TRIGGER) ?? element;
      const hover = () => run(0);
      if (this.dataset.trigger === "hover") {
        target.addEventListener("pointerenter", hover);
        target.addEventListener("focusin", hover);
      } else {
        output.textContent = scrambler(text, set)(0);
        if (
          this.dataset.trigger === "mount" ||
          typeof IntersectionObserver === "undefined"
        )
          run(delay);
        else {
          // Scrambled while off screen, then decoded once when it scrolls into view.
          observer = new IntersectionObserver((entries) => {
            if (!entries.some((entry) => entry.isIntersecting)) return;
            observer?.disconnect();
            run(delay);
          });
          observer.observe(element);
        }
      }
      this.cleanup = () => {
        observer?.disconnect();
        cancelAnimationFrame(frame);
        target.removeEventListener("pointerenter", hover);
        target.removeEventListener("focusin", hover);
        output.textContent = text;
      };
    }

    disconnectedCallback() {
      this.cleanup();
    }
  }

  if (!customElements.get("markas-text-scramble"))
    customElements.define("markas-text-scramble", MarkasTextScramble);
</script>
```

```astro
---
import TextScramble from "@/components/markas/TextScramble.astro";
---

<h2 class="text-3xl font-semibold">
  <TextScramble text="Operasi Nusantara" trigger="view" />
</h2>
<TextScramble text="99.98%" trigger="view" charset="digits" delay={150} />
<a href="/brief"><TextScramble text="Buka brief" charset="symbols" /></a>
```

### Angular

Simpan di `src/app/markas/text-scramble.component.ts`. Tanpa dependensi tambahan.

```ts
import {
  afterRenderEffect,
  ChangeDetectionStrategy,
  Component,
  ElementRef,
  inject,
  input,
  linkedSignal,
  numberAttribute,
} from "@angular/core";

const root = "inline-grid tabular-nums";
const layer = "col-start-1 row-start-1";
const holder = "invisible col-start-1 row-start-1";

const charsets = {
  letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  digits: "0123456789",
  symbols: "!@$%&*+=<>/?{}[]",
  binary: "01",
};

/** Random letters change at most every 50 ms, so it reads as an effect, not a flicker. */
const FRAME = 50;
/** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
const TRIGGER = "a, button, label, [tabindex]";

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Deterministic random (Park-Miller): the same scrambled letters on every run and in every framework. */
function scrambler(text: string, charset: string) {
  const chars = Array.from(text);
  let seed = 1;
  const pick = () => {
    seed = (seed * 48271) % 2147483647;
    return charset[seed % charset.length];
  };
  return (revealed: number) =>
    chars
      .map((char, i) => (i < revealed || char.trim() === "" ? char : pick()))
      .join("");
}

export type TextScrambleTrigger = "hover" | "view" | "mount";
export type TextScrambleCharset = keyof typeof charsets;

type ScrambleOptions = {
  text: string;
  trigger: TextScrambleTrigger;
  charset: TextScrambleCharset;
  duration: number;
  delay: number;
};

/** Wires the trigger and runs the scramble, writing each frame through `write`. Returns a stop function. */
function startScramble(
  element: HTMLElement,
  options: ScrambleOptions,
  write: (text: string) => void,
) {
  const set = charsets[options.charset];
  const total = Array.from(options.text).length;
  let frame = 0;
  write(options.text);
  let observer: IntersectionObserver | undefined;

  // Scramble every letter, then reveal from left to right until the real text is whole again.
  const run = (wait: number) => {
    if (frame) return;
    const scramble = scrambler(options.text, set);
    let began: number | undefined;
    let last = -FRAME;
    const tick = (now: number) => {
      began ??= now;
      const progress = Math.min((now - began - wait) / options.duration, 1);
      if (now - last >= FRAME || progress >= 1) {
        last = now;
        write(scramble(Math.max(Math.floor(progress * total), 0)));
      }
      frame = progress < 1 ? requestAnimationFrame(tick) : 0;
    };
    frame = requestAnimationFrame(tick);
  };

  const target = element.closest<HTMLElement>(TRIGGER) ?? element;
  const hover = () => run(0);
  if (options.trigger === "hover") {
    target.addEventListener("pointerenter", hover);
    target.addEventListener("focusin", hover);
  } else {
    write(scrambler(options.text, set)(0));
    if (
      options.trigger === "mount" ||
      typeof IntersectionObserver === "undefined"
    )
      run(options.delay);
    else {
      // Scrambled while off screen, then decoded once when it scrolls into view.
      observer = new IntersectionObserver((entries) => {
        if (!entries.some((entry) => entry.isIntersecting)) return;
        observer?.disconnect();
        run(options.delay);
      });
      observer.observe(element);
    }
  }
  return () => {
    observer?.disconnect();
    cancelAnimationFrame(frame);
    target.removeEventListener("pointerenter", hover);
    target.removeEventListener("focusin", hover);
  };
}

/** Attribute selector on a span, so the user's class and aria-* stay on the root. */
@Component({
  selector: "span[markas-text-scramble]",
  changeDetection: ChangeDetectionStrategy.OnPush,
  host: { "[class]": "root" },
  template: `<span class="sr-only">{{ text() }}</span
    ><span aria-hidden="true" [class]="holder">{{ text() }}</span
    ><span aria-hidden="true" [class]="layer">{{ display() }}</span>`,
})
export class TextScramble {
  readonly text = input.required<string>();
  readonly trigger = input<TextScrambleTrigger>("hover");
  readonly charset = input<TextScrambleCharset>("letters");
  readonly duration = input(800, { transform: numberAttribute });
  readonly delay = input(0, { transform: numberAttribute });

  protected readonly root = root;
  protected readonly layer = layer;
  protected readonly holder = holder;
  /** The visible text. It goes back to the real text when the text changes. */
  protected readonly display = linkedSignal(() => this.text());
  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);

  constructor() {
    afterRenderEffect((onCleanup) => {
      const options = {
        text: this.text(),
        trigger: this.trigger(),
        charset: this.charset(),
        duration: this.duration(),
        delay: this.delay(),
      };
      if (reducedMotion()) return;
      onCleanup(
        startScramble(this.host.nativeElement, options, (value) =>
          this.display.set(value),
        ),
      );
    });
  }
}
```

```ts
import { Component } from "@angular/core";
import { TextScramble } from "./markas/text-scramble.component";

@Component({
  selector: "app-stats",
  imports: [TextScramble],
  template: `
    <h2 class="text-3xl font-semibold">
      <span markas-text-scramble text="Operasi Nusantara" trigger="view"></span>
    </h2>
    <span
      markas-text-scramble
      text="99.98%"
      trigger="view"
      charset="digits"
      delay="150"
    ></span>
    <a href="/brief">
      <span markas-text-scramble text="Buka brief" charset="symbols"></span>
    </a>
  `,
})
export class Stats {}
```

Angular memakai attribute selector pada span: `<span markas-text-scramble>`. Di Astro teks dirender di server lalu script kecil mengacaknya.

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `text` | `string` | - | Teks akhir. Dirender di server dan inilah yang dibaca screen reader. |
| `trigger` | `"hover" \| "view" \| "mount"` | "hover" | hover berjalan saat hover dan fokus pada link atau tombol terdekat, view berjalan sekali saat teks masuk layar, mount langsung berjalan. |
| `charset` | `"letters" \| "digits" \| "symbols" \| "binary"` | "letters" | Karakter yang dipakai saat mengacak. |
| `duration` | `number` | 800 | Milidetik dari teracak penuh sampai terbaca penuh. |
| `delay` | `number` | 0 | Milidetik teks tetap teracak sebelum dekripsi dimulai, untuk view dan mount. Pakai delay bertingkat agar deretan statistik terbuka berurutan. |

## Aksesibilitas

- Screen reader membaca teks akhir sekali dari salinan tersembunyi; lapisan acak memakai aria-hidden.
- Salinan teks akhir yang tidak terlihat menjaga lebar tetap sehingga elemen di sekitarnya tidak bergeser.
- Dengan reduced motion, teks akhir langsung tampil dan tidak pernah teracak.

## Catatan

- `hover` berjalan saat hover dan fokus pada link atau tombol terdekat. `view` dan `mount` mulai dalam keadaan teracak lalu terdekripsi sekali; `view` menunggu sampai teks masuk layar.
- Salinan teks akhir yang tidak terlihat menahan lebar, sehingga tata letak tidak bergeser saat teracak.
- Karakter acak berasal dari generator dengan seed tetap, sehingga setiap putaran terlihat sama di setiap framework.
- Screen reader hanya membaca teks akhir. Dengan reduced motion, teks akhir langsung tampil dan tidak pernah teracak. Versi Blade butuh Alpine.js.
