# Image Compare

Before and after view with a divider you drag, click, or move with the keyboard. Horizontal or vertical, and it takes any content, including img.

- Category: MarkasUI
- Status: stable
- Registry: https://markas.jenderalcorp.com/r/image-compare.json
- CLI: `npx markasui@latest add image-compare`

## When to use

Showing a change on the same subject: photo edits, redesigns, renovations, filters, map layers, light and dark themes.

- Give both sides the same size and framing, for example img with class size-full object-cover inside a fixed aspect ratio
- Write alt text on both images that names the state, such as Living room before renovation
- Name the whole comparison with aria-label on the component
- Change beforeLabel and afterLabel to the real states, such as Original and Edited

## Code

### Blade

Save at `resources/views/components/markas/image-compare.blade.php`. Dependencies: alpinejs.

```blade
@props([
    'orientation' => 'horizontal',
    'position' => 50,
    'step' => 5,
    'beforeLabel' => 'Before',
    'afterLabel' => 'After',
    'sliderLabel' => 'Comparison position',
])

@php
    $root = 'group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none';
    $layer = 'relative col-start-1 row-start-1 min-w-0 bg-surface';
    $motion = 'duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none';
    $label = 'pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm';
    $divider = 'pointer-events-none absolute z-10 bg-surface';
    $handle = 'pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none';
    $iconClass = 'size-5';
    $orientations = [
        'horizontal' => [
            'root' => 'cursor-ew-resize touch-pan-y',
            'clip' => '[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]',
            'divider' => 'inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]',
            'before' => 'top-3 left-3',
            'after' => 'top-3 right-3',
            'icon' => '',
        ],
        'vertical' => [
            'root' => 'cursor-ns-resize touch-pan-x',
            'clip' => '[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]',
            'divider' => 'inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]',
            'before' => 'top-3 left-3',
            'after' => 'bottom-3 left-3',
            'icon' => 'rotate-90',
        ],
    ];
    $o = $orientations[$orientation] ?? $orientations['horizontal'];
    $orientation = isset($orientations[$orientation]) ? $orientation : 'horizontal';
    $position = min(100, max(0, (float) $position));
    $cx = fn (string ...$classes) => implode(' ', array_filter($classes));
@endphp

{{-- Drag anywhere, click a spot, or use the arrow keys, Page Up/Down, Home, and End on the handle. --}}
<div
    x-data="{
        position: {{ $position }},
        step: {{ (float) $step }},
        vertical: {{ $orientation === 'vertical' ? 'true' : 'false' }},
        pressed: false,
        dragging: false,
        move(next) {
            this.position = Math.min(100, Math.max(0, next));
            this.$dispatch('position-change', this.position);
        },
        fromPointer(event) {
            const rect = this.$root.getBoundingClientRect();
            this.move(this.vertical ? ((event.clientY - rect.top) / rect.height) * 100 : ((event.clientX - rect.left) / rect.width) * 100);
        },
        down(event) {
            if (event.button !== 0) return;
            event.preventDefault();
            this.pressed = true;
            this.$refs.handle.focus({ preventScroll: true });
            this.$root.setPointerCapture?.(event.pointerId);
            this.fromPointer(event);
        },
        drag(event) {
            if (! this.pressed) return;
            this.dragging = true;
            this.fromPointer(event);
        },
        release() {
            this.pressed = false;
            this.dragging = false;
        },
        key(event) {
            const flip = this.vertical ? -1 : 1;
            const at = this.position;
            const moves = { ArrowRight: at + this.step, ArrowLeft: at - this.step, ArrowUp: at + this.step * flip, ArrowDown: at - this.step * flip, PageUp: at + 10, PageDown: at - 10, Home: 0, End: 100 };
            const next = moves[event.key];
            if (next === undefined) return;
            event.preventDefault();
            this.move(next);
        },
    }"
    data-orientation="{{ $orientation }}"
    x-bind:data-dragging="dragging ? '' : null"
    x-bind:style="{ '--position': position + '%' }"
    x-on:pointerdown="down($event)"
    x-on:pointermove="drag($event)"
    x-on:pointerup="release()"
    x-on:pointercancel="release()"
    {{ $attributes->merge(['role' => 'group', 'style' => '--position: '.$position.'%'])->class([$root, $o['root']]) }}
>
    <div class="{{ $layer }}">
        {{ $__laravel_slots['after'] ?? '' }}
        <span class="{{ $cx($label, $o['after']) }}">{{ $afterLabel }}</span>
    </div>
    <div class="{{ $cx($layer, $o['clip'], $motion) }}">
        {{ $__laravel_slots['before'] ?? '' }}
        <span class="{{ $cx($label, $o['before']) }}">{{ $beforeLabel }}</span>
    </div>
    <div class="{{ $cx($divider, $o['divider'], $motion) }}">
        <div
            x-ref="handle"
            role="slider"
            tabindex="0"
            aria-label="{{ $sliderLabel }}"
            aria-orientation="{{ $orientation }}"
            aria-valuemin="0"
            aria-valuemax="100"
            aria-valuenow="{{ round($position) }}"
            aria-valuetext="{{ round($position) }}%"
            x-bind:aria-valuenow="Math.round(position)"
            x-bind:aria-valuetext="Math.round(position) + '%'"
            x-on:keydown="key($event)"
            class="{{ $handle }}"
        >
            <svg class="{{ $cx($iconClass, $o['icon']) }}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m9 7-5 5 5 5M15 7l5 5-5 5" /></svg>
        </div>
    </div>
</div>
```

```blade
<x-markas.image-compare aria-label="Living room renovation" :position="40">
    <x-slot:before>
        <img src="/img/before.jpg" alt="Living room before renovation" class="aspect-video size-full object-cover" />
    </x-slot:before>
    <x-slot:after>
        <img src="/img/after.jpg" alt="Living room after renovation" class="aspect-video size-full object-cover" />
    </x-slot:after>
</x-markas.image-compare>
```

Needs Alpine.js. The component dispatches `position-change` with the new percent.

### React

Save at `src/components/markas/ImageCompare.tsx`. No extra dependencies.

```tsx
"use client";

import {
  useRef,
  useState,
  type ComponentProps,
  type CSSProperties,
  type KeyboardEvent,
  type PointerEvent,
  type ReactNode,
} from "react";

const root =
  "group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none";
const layer = "relative col-start-1 row-start-1 min-w-0 bg-surface";
const motion =
  "duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none";
const label =
  "pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm";
const divider = "pointer-events-none absolute z-10 bg-surface";
const handle =
  "pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none";
const iconClass = "size-5";
const orientations = {
  horizontal: {
    root: "cursor-ew-resize touch-pan-y",
    clip: "[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]",
    divider:
      "inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]",
    before: "top-3 left-3",
    after: "top-3 right-3",
    icon: "",
  },
  vertical: {
    root: "cursor-ns-resize touch-pan-x",
    clip: "[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]",
    divider:
      "inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]",
    before: "top-3 left-3",
    after: "bottom-3 left-3",
    icon: "rotate-90",
  },
};

const PAGE_STEP = 10;

const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");
const clamp = (value: number) => Math.min(100, Math.max(0, value));

export type ImageCompareProps = Omit<ComponentProps<"div">, "children"> & {
  /** Content shown on the start side (left or top): an img, svg, or any markup. */
  before: ReactNode;
  /** Content shown on the end side (right or bottom). */
  after: ReactNode;
  orientation?: keyof typeof orientations;
  /** Starting divider position in percent. */
  defaultPosition?: number;
  /** Percent moved per arrow key press. */
  step?: number;
  onPositionChange?: (position: number) => void;
  beforeLabel?: string;
  afterLabel?: string;
  sliderLabel?: string;
};

export function ImageCompare({
  before,
  after,
  orientation = "horizontal",
  defaultPosition = 50,
  step = 5,
  onPositionChange,
  beforeLabel = "Before",
  afterLabel = "After",
  sliderLabel = "Comparison position",
  className,
  style,
  ...props
}: ImageCompareProps) {
  const o = orientations[orientation];
  const vertical = orientation === "vertical";
  const [position, setPosition] = useState(clamp(defaultPosition));
  const [dragging, setDragging] = useState(false);
  const pressed = useRef(false);
  const handleRef = useRef<HTMLDivElement>(null);

  const move = (next: number) => {
    const value = clamp(next);
    setPosition(value);
    onPositionChange?.(value);
  };
  const fromPointer = (event: PointerEvent<HTMLDivElement>) => {
    const rect = event.currentTarget.getBoundingClientRect();
    move(
      vertical
        ? ((event.clientY - rect.top) / rect.height) * 100
        : ((event.clientX - rect.left) / rect.width) * 100,
    );
  };

  const onPointerDown = (event: PointerEvent<HTMLDivElement>) => {
    if (event.button !== 0) return;
    event.preventDefault();
    pressed.current = true;
    handleRef.current?.focus({ preventScroll: true });
    event.currentTarget.setPointerCapture?.(event.pointerId);
    fromPointer(event);
  };
  const onPointerMove = (event: PointerEvent<HTMLDivElement>) => {
    if (!pressed.current) return;
    setDragging(true);
    fromPointer(event);
  };
  const release = () => {
    pressed.current = false;
    setDragging(false);
  };

  const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
    const flip = vertical ? -1 : 1;
    const moves: Record<string, number> = {
      ArrowRight: position + step,
      ArrowLeft: position - step,
      ArrowUp: position + step * flip,
      ArrowDown: position - step * flip,
      PageUp: position + PAGE_STEP,
      PageDown: position - PAGE_STEP,
      Home: 0,
      End: 100,
    };
    const next = moves[event.key];
    if (next === undefined) return;
    event.preventDefault();
    move(next);
  };

  return (
    <div
      role="group"
      {...props}
      data-orientation={orientation}
      data-dragging={dragging ? "" : undefined}
      className={cx(root, o.root, className)}
      style={{ ...style, "--position": `${position}%` } as CSSProperties}
      onPointerDown={onPointerDown}
      onPointerMove={onPointerMove}
      onPointerUp={release}
      onPointerCancel={release}
    >
      <div className={layer}>
        {after}
        <span className={cx(label, o.after)}>{afterLabel}</span>
      </div>
      <div className={cx(layer, o.clip, motion)}>
        {before}
        <span className={cx(label, o.before)}>{beforeLabel}</span>
      </div>
      <div className={cx(divider, o.divider, motion)}>
        <div
          ref={handleRef}
          role="slider"
          tabIndex={0}
          aria-label={sliderLabel}
          aria-orientation={orientation}
          aria-valuemin={0}
          aria-valuemax={100}
          aria-valuenow={Math.round(position)}
          aria-valuetext={`${Math.round(position)}%`}
          className={handle}
          onKeyDown={onKeyDown}
        >
          <svg
            className={cx(iconClass, o.icon)}
            viewBox="0 0 24 24"
            fill="none"
            stroke="currentColor"
            strokeWidth="1.5"
            strokeLinecap="round"
            strokeLinejoin="round"
            aria-hidden="true"
          >
            <path d="m9 7-5 5 5 5M15 7l5 5-5 5" />
          </svg>
        </div>
      </div>
    </div>
  );
}
```

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

<ImageCompare
  aria-label="Living room renovation"
  defaultPosition={40}
  before={<img src="/img/before.jpg" alt="Living room before renovation" />}
  after={<img src="/img/after.jpg" alt="Living room after renovation" />}
/>;
```

### Vue

Save at `src/components/markas/ImageCompare.vue`. No extra dependencies.

```vue
<script setup lang="ts">
import { computed, ref } from "vue";

const props = withDefaults(
  defineProps<{
    orientation?: "horizontal" | "vertical";
    /** Percent moved per arrow key press. */
    step?: number;
    beforeLabel?: string;
    afterLabel?: string;
    sliderLabel?: string;
  }>(),
  {
    orientation: "horizontal",
    step: 5,
    beforeLabel: "Before",
    afterLabel: "After",
    sliderLabel: "Comparison position",
  },
);
/** Divider position in percent, measured from the start (left or top). */
const position = defineModel<number>("position", { default: 50 });
defineSlots<{ before?: () => unknown; after?: () => unknown }>();

const root =
  "group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none";
const layer = "relative col-start-1 row-start-1 min-w-0 bg-surface";
const motion =
  "duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none";
const label =
  "pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm";
const divider = "pointer-events-none absolute z-10 bg-surface";
const handle =
  "pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none";
const iconClass = "size-5";
const orientations = {
  horizontal: {
    root: "cursor-ew-resize touch-pan-y",
    clip: "[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]",
    divider:
      "inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]",
    before: "top-3 left-3",
    after: "top-3 right-3",
    icon: "",
  },
  vertical: {
    root: "cursor-ns-resize touch-pan-x",
    clip: "[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]",
    divider:
      "inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]",
    before: "top-3 left-3",
    after: "bottom-3 left-3",
    icon: "rotate-90",
  },
};

const PAGE_STEP = 10;

const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");
const clamp = (value: number) => Math.min(100, Math.max(0, value));

const o = computed(() => orientations[props.orientation]);
const vertical = computed(() => props.orientation === "vertical");
const current = computed(() => clamp(position.value));
const dragging = ref(false);
const handleEl = ref<HTMLElement>();
let pressed = false;

const move = (next: number) => {
  position.value = clamp(next);
};
function fromPointer(event: PointerEvent) {
  const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
  move(
    vertical.value
      ? ((event.clientY - rect.top) / rect.height) * 100
      : ((event.clientX - rect.left) / rect.width) * 100,
  );
}

function onPointerdown(event: PointerEvent) {
  if (event.button !== 0) return;
  event.preventDefault();
  pressed = true;
  handleEl.value?.focus({ preventScroll: true });
  (event.currentTarget as HTMLElement).setPointerCapture?.(event.pointerId);
  fromPointer(event);
}
function onPointermove(event: PointerEvent) {
  if (!pressed) return;
  dragging.value = true;
  fromPointer(event);
}
function release() {
  pressed = false;
  dragging.value = false;
}

function onKeydown(event: KeyboardEvent) {
  const flip = vertical.value ? -1 : 1;
  const at = current.value;
  const moves: Record<string, number> = {
    ArrowRight: at + props.step,
    ArrowLeft: at - props.step,
    ArrowUp: at + props.step * flip,
    ArrowDown: at - props.step * flip,
    PageUp: at + PAGE_STEP,
    PageDown: at - PAGE_STEP,
    Home: 0,
    End: 100,
  };
  const next = moves[event.key];
  if (next === undefined) return;
  event.preventDefault();
  move(next);
}
</script>

<template>
  <div
    role="group"
    :data-orientation="props.orientation"
    :data-dragging="dragging ? '' : undefined"
    :class="cx(root, o.root)"
    :style="{ '--position': `${current}%` }"
    @pointerdown="onPointerdown"
    @pointermove="onPointermove"
    @pointerup="release"
    @pointercancel="release"
  >
    <div :class="layer">
      <slot name="after" />
      <span :class="cx(label, o.after)">{{ props.afterLabel }}</span>
    </div>
    <div :class="cx(layer, o.clip, motion)">
      <slot name="before" />
      <span :class="cx(label, o.before)">{{ props.beforeLabel }}</span>
    </div>
    <div :class="cx(divider, o.divider, motion)">
      <div
        ref="handleEl"
        role="slider"
        tabindex="0"
        :aria-label="props.sliderLabel"
        :aria-orientation="props.orientation"
        aria-valuemin="0"
        aria-valuemax="100"
        :aria-valuenow="Math.round(current)"
        :aria-valuetext="`${Math.round(current)}%`"
        :class="handle"
        @keydown="onKeydown"
      >
        <svg
          :class="cx(iconClass, o.icon)"
          viewBox="0 0 24 24"
          fill="none"
          stroke="currentColor"
          stroke-width="1.5"
          stroke-linecap="round"
          stroke-linejoin="round"
          aria-hidden="true"
        >
          <path d="m9 7-5 5 5 5M15 7l5 5-5 5" />
        </svg>
      </div>
    </div>
  </div>
</template>
```

```vue
<template>
  <ImageCompare v-model:position="position" aria-label="Living room renovation">
    <template #before
      ><img src="/img/before.jpg" alt="Living room before renovation"
    /></template>
    <template #after
      ><img src="/img/after.jpg" alt="Living room after renovation"
    /></template>
  </ImageCompare>
</template>
```

### Svelte

Save at `src/lib/components/markas/ImageCompare.svelte`. No extra dependencies.

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

  const root =
    "group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none";
  const layer = "relative col-start-1 row-start-1 min-w-0 bg-surface";
  const motion =
    "duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none";
  const label =
    "pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm";
  const divider = "pointer-events-none absolute z-10 bg-surface";
  const handle =
    "pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none";
  const iconClass = "size-5";
  const orientations = {
    horizontal: {
      root: "cursor-ew-resize touch-pan-y",
      clip: "[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]",
      divider:
        "inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]",
      before: "top-3 left-3",
      after: "top-3 right-3",
      icon: "",
    },
    vertical: {
      root: "cursor-ns-resize touch-pan-x",
      clip: "[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]",
      divider:
        "inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]",
      before: "top-3 left-3",
      after: "bottom-3 left-3",
      icon: "rotate-90",
    },
  };

  const PAGE_STEP = 10;

  const clamp = (value: number) => Math.min(100, Math.max(0, value));

  type Props = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
    /** Content shown on the start side (left or top): an img, svg, or any markup. */
    before?: Snippet;
    /** Content shown on the end side (right or bottom). */
    after?: Snippet;
    orientation?: keyof typeof orientations;
    /** Divider position in percent, bindable with bind:position. */
    position?: number;
    /** Percent moved per arrow key press. */
    step?: number;
    onPositionChange?: (position: number) => void;
    beforeLabel?: string;
    afterLabel?: string;
    sliderLabel?: string;
  };

  let {
    before,
    after,
    orientation = "horizontal",
    position = $bindable(50),
    step = 5,
    onPositionChange,
    beforeLabel = "Before",
    afterLabel = "After",
    sliderLabel = "Comparison position",
    class: className,
    style,
    ...rest
  }: Props = $props();

  const o = $derived(orientations[orientation]);
  const vertical = $derived(orientation === "vertical");
  const current = $derived(clamp(position));
  let dragging = $state(false);
  let handleEl = $state<HTMLDivElement>();
  let pressed = false;

  function move(next: number) {
    position = clamp(next);
    onPositionChange?.(position);
  }

  function fromPointer(
    event: PointerEvent & { currentTarget: EventTarget & HTMLDivElement },
  ) {
    const rect = event.currentTarget.getBoundingClientRect();
    move(
      vertical
        ? ((event.clientY - rect.top) / rect.height) * 100
        : ((event.clientX - rect.left) / rect.width) * 100,
    );
  }

  function onpointerdown(
    event: PointerEvent & { currentTarget: EventTarget & HTMLDivElement },
  ) {
    if (event.button !== 0) return;
    event.preventDefault();
    pressed = true;
    handleEl?.focus({ preventScroll: true });
    event.currentTarget.setPointerCapture?.(event.pointerId);
    fromPointer(event);
  }

  function onpointermove(
    event: PointerEvent & { currentTarget: EventTarget & HTMLDivElement },
  ) {
    if (!pressed) return;
    dragging = true;
    fromPointer(event);
  }

  function release() {
    pressed = false;
    dragging = false;
  }

  function onkeydown(event: KeyboardEvent) {
    const flip = vertical ? -1 : 1;
    const at = current;
    const moves: Record<string, number> = {
      ArrowRight: at + step,
      ArrowLeft: at - step,
      ArrowUp: at + step * flip,
      ArrowDown: at - step * flip,
      PageUp: at + PAGE_STEP,
      PageDown: at - PAGE_STEP,
      Home: 0,
      End: 100,
    };
    const next = moves[event.key];
    if (next === undefined) return;
    event.preventDefault();
    move(next);
  }
</script>

<div
  role="group"
  {...rest}
  data-orientation={orientation}
  data-dragging={dragging ? "" : undefined}
  class={[root, o.root, className]}
  style={`${style ? `${style}; ` : ""}--position: ${current}%`}
  {onpointerdown}
  {onpointermove}
  onpointerup={release}
  onpointercancel={release}
>
  <div class={layer}>
    {@render after?.()}
    <span class={[label, o.after]}>{afterLabel}</span>
  </div>
  <div class={[layer, o.clip, motion]}>
    {@render before?.()}
    <span class={[label, o.before]}>{beforeLabel}</span>
  </div>
  <div class={[divider, o.divider, motion]}>
    <div
      bind:this={handleEl}
      role="slider"
      tabindex="0"
      aria-label={sliderLabel}
      aria-orientation={orientation}
      aria-valuemin={0}
      aria-valuemax={100}
      aria-valuenow={Math.round(current)}
      aria-valuetext={`${Math.round(current)}%`}
      class={handle}
      {onkeydown}
    >
      <svg
        class={[iconClass, o.icon]}
        viewBox="0 0 24 24"
        fill="none"
        stroke="currentColor"
        stroke-width="1.5"
        stroke-linecap="round"
        stroke-linejoin="round"
        aria-hidden="true"
      >
        <path d="m9 7-5 5 5 5M15 7l5 5-5 5" />
      </svg>
    </div>
  </div>
</div>
```

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

  let position = $state(50);
</script>

<ImageCompare bind:position aria-label="Kitchen renovation">
  {#snippet before()}<img src="/img/kitchen-old.webp" alt="" />{/snippet}
  {#snippet after()}<img src="/img/kitchen-new.webp" alt="" />{/snippet}
</ImageCompare>
```

### Astro

Save at `src/components/markas/ImageCompare.astro`. No extra dependencies.

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

const root =
  "group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none";
const layer = "relative col-start-1 row-start-1 min-w-0 bg-surface";
const motion =
  "duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none";
const label =
  "pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm";
const divider = "pointer-events-none absolute z-10 bg-surface";
const handle =
  "pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none";
const iconClass = "size-5";
const orientations = {
  horizontal: {
    root: "cursor-ew-resize touch-pan-y",
    clip: "[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]",
    divider:
      "inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]",
    before: "top-3 left-3",
    after: "top-3 right-3",
    icon: "",
  },
  vertical: {
    root: "cursor-ns-resize touch-pan-x",
    clip: "[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]",
    divider:
      "inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]",
    before: "top-3 left-3",
    after: "bottom-3 left-3",
    icon: "rotate-90",
  },
};

type Props = HTMLAttributes<"div"> & {
  orientation?: keyof typeof orientations;
  /** Starting divider position in percent. */
  position?: number;
  /** Percent moved per arrow key press. */
  step?: number;
  beforeLabel?: string;
  afterLabel?: string;
  sliderLabel?: string;
};

const {
  orientation = "horizontal",
  position: start = 50,
  step = 5,
  beforeLabel = "Before",
  afterLabel = "After",
  sliderLabel = "Comparison position",
  class: className,
  style,
  ...rest
} = Astro.props;
const o = orientations[orientation];
const position = Math.min(100, Math.max(0, Number(start)));
const userStyle = typeof style === "string" && style ? `${style}; ` : "";
---

<div
  role="group"
  {...rest}
  data-markas-image-compare
  data-step={Number(step)}
  data-orientation={orientation}
  class:list={[root, o.root, className]}
  style={`${userStyle}--position: ${position}%`}
>
  <div class={layer}>
    <slot name="after" />
    <span class:list={[label, o.after]}>{afterLabel}</span>
  </div>
  <div class:list={[layer, o.clip, motion]}>
    <slot name="before" />
    <span class:list={[label, o.before]}>{beforeLabel}</span>
  </div>
  <div class:list={[divider, o.divider, motion]}>
    <div
      role="slider"
      tabindex="0"
      aria-label={sliderLabel}
      aria-orientation={orientation}
      aria-valuemin="0"
      aria-valuemax="100"
      aria-valuenow={Math.round(position)}
      aria-valuetext={`${Math.round(position)}%`}
      class={handle}
    >
      <svg
        class:list={[iconClass, o.icon]}
        viewBox="0 0 24 24"
        fill="none"
        stroke="currentColor"
        stroke-width="1.5"
        stroke-linecap="round"
        stroke-linejoin="round"
        aria-hidden="true"
      >
        <path d="m9 7-5 5 5 5M15 7l5 5-5 5"></path>
      </svg>
    </div>
  </div>
</div>

<script>
  const PAGE_STEP = 10;
  const pressed = new WeakSet<HTMLElement>();

  const compareOf = (target: EventTarget | null) =>
    target instanceof Element
      ? target.closest<HTMLElement>("[data-markas-image-compare]")
      : null;
  const positionOf = (root: HTMLElement) =>
    parseFloat(root.style.getPropertyValue("--position")) || 0;

  /** Move the divider, update the slider value, and announce it with a position-change event. */
  function move(root: HTMLElement, next: number) {
    const value = Math.min(100, Math.max(0, next));
    root.style.setProperty("--position", `${value}%`);
    const slider = root.querySelector("[role=slider]");
    slider?.setAttribute("aria-valuenow", String(Math.round(value)));
    slider?.setAttribute("aria-valuetext", `${Math.round(value)}%`);
    root.dispatchEvent(
      new CustomEvent("position-change", { detail: value, bubbles: true }),
    );
  }

  function fromPointer(root: HTMLElement, event: PointerEvent) {
    const rect = root.getBoundingClientRect();
    move(
      root,
      root.dataset.orientation === "vertical"
        ? ((event.clientY - rect.top) / rect.height) * 100
        : ((event.clientX - rect.left) / rect.width) * 100,
    );
  }

  function release(event: Event) {
    const root = compareOf(event.target);
    if (!root) return;
    pressed.delete(root);
    delete root.dataset.dragging;
  }

  // One set of listeners per page serves every comparison: drag anywhere, click a spot, or use the
  // arrow keys, Page Up/Down, Home, and End on the handle.
  document.addEventListener("pointerdown", (event) => {
    const root = compareOf(event.target);
    if (!root || event.button !== 0) return;
    event.preventDefault();
    pressed.add(root);
    root.querySelector<HTMLElement>("[role=slider]")?.focus({
      preventScroll: true,
    });
    root.setPointerCapture?.(event.pointerId);
    fromPointer(root, event);
  });
  document.addEventListener("pointermove", (event) => {
    const root = compareOf(event.target);
    if (!root || !pressed.has(root)) return;
    root.dataset.dragging = "";
    fromPointer(root, event);
  });
  document.addEventListener("pointerup", release);
  document.addEventListener("pointercancel", release);
  document.addEventListener("keydown", (event) => {
    const target = event.target;
    const root = compareOf(target);
    if (!root || !(target instanceof Element) || target.getAttribute("role") !== "slider")
      return;
    const step = Number(root.dataset.step) || 0;
    const flip = root.dataset.orientation === "vertical" ? -1 : 1;
    const at = positionOf(root);
    const moves: Record<string, number> = {
      ArrowRight: at + step,
      ArrowLeft: at - step,
      ArrowUp: at + step * flip,
      ArrowDown: at - step * flip,
      PageUp: at + PAGE_STEP,
      PageDown: at - PAGE_STEP,
      Home: 0,
      End: 100,
    };
    const next = moves[event.key];
    if (next === undefined) return;
    event.preventDefault();
    move(root, next);
  });
</script>
```

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

<ImageCompare aria-label="Kitchen renovation">
  <img slot="before" src="/img/kitchen-old.webp" alt="" />
  <img slot="after" src="/img/kitchen-new.webp" alt="" />
</ImageCompare>
```

A small bundled script serves every comparison on the page and dispatches `position-change`.

### Angular

Save at `src/app/markas/image-compare.component.ts`. No extra dependencies.

```ts
import {
  ChangeDetectionStrategy,
  Component,
  computed,
  type ElementRef,
  input,
  linkedSignal,
  numberAttribute,
  output,
  signal,
  viewChild,
} from "@angular/core";

const root =
  "group/compare relative isolate grid overflow-hidden rounded-xl select-none [&_img]:pointer-events-none";
const layer = "relative col-start-1 row-start-1 min-w-0 bg-surface";
const motion =
  "duration-200 ease-out group-data-dragging/compare:transition-none motion-reduce:transition-none";
const label =
  "pointer-events-none absolute rounded-full border border-line bg-surface/85 px-2.5 py-1 text-xs font-medium text-ink backdrop-blur-sm";
const divider = "pointer-events-none absolute z-10 bg-surface";
const handle =
  "pointer-events-auto absolute top-1/2 left-1/2 grid size-10 -translate-1/2 place-items-center rounded-full border border-line bg-surface text-ink shadow-overlay transition-[scale] duration-150 ease-out group-data-dragging/compare:scale-110 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary motion-reduce:transition-none";
const iconClass = "size-5";
const orientations = {
  horizontal: {
    root: "cursor-ew-resize touch-pan-y",
    clip: "[clip-path:inset(0_calc(100%_-_var(--position))_0_0)] transition-[clip-path]",
    divider:
      "inset-y-0 left-(--position) w-0.5 -translate-x-1/2 transition-[left]",
    before: "top-3 left-3",
    after: "top-3 right-3",
    icon: "",
  },
  vertical: {
    root: "cursor-ns-resize touch-pan-x",
    clip: "[clip-path:inset(0_0_calc(100%_-_var(--position))_0)] transition-[clip-path]",
    divider:
      "inset-x-0 top-(--position) h-0.5 -translate-y-1/2 transition-[top]",
    before: "top-3 left-3",
    after: "bottom-3 left-3",
    icon: "rotate-90",
  },
};

const PAGE_STEP = 10;

const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");
const clamp = (value: number) => Math.min(100, Math.max(0, value));

export type ImageCompareOrientation = keyof typeof orientations;

/**
 * Slots: an element with the `before` attribute fills the start side (left or top), one with
 * `after` the end side. Supports [(position)]. The host stays out of layout; the user's class
 * lands on the group.
 */
@Component({
  selector: "markas-image-compare",
  changeDetection: ChangeDetectionStrategy.OnPush,
  host: { class: "contents", "[attr.aria-label]": "null" },
  template: `
    <div
      role="group"
      [attr.aria-label]="ariaLabel()"
      [attr.data-orientation]="orientation()"
      [attr.data-dragging]="dragging() ? '' : null"
      [class]="classes()"
      [style.--position]="current() + '%'"
      (pointerdown)="onPointerDown($event)"
      (pointermove)="onPointerMove($event)"
      (pointerup)="release()"
      (pointercancel)="release()"
    >
      <div [class]="layer">
        <ng-content select="[after]" />
        <span [class]="afterClass()">{{ afterLabel() }}</span>
      </div>
      <div [class]="clipClass()">
        <ng-content select="[before]" />
        <span [class]="beforeClass()">{{ beforeLabel() }}</span>
      </div>
      <div [class]="dividerClass()">
        <div
          #handleEl
          role="slider"
          tabindex="0"
          [attr.aria-label]="sliderLabel()"
          [attr.aria-orientation]="orientation()"
          aria-valuemin="0"
          aria-valuemax="100"
          [attr.aria-valuenow]="rounded()"
          [attr.aria-valuetext]="rounded() + '%'"
          [class]="handle"
          (keydown)="onKeyDown($event)"
        >
          <svg
            [class]="iconClasses()"
            viewBox="0 0 24 24"
            fill="none"
            stroke="currentColor"
            stroke-width="1.5"
            stroke-linecap="round"
            stroke-linejoin="round"
            aria-hidden="true"
          >
            <path d="m9 7-5 5 5 5M15 7l5 5-5 5" />
          </svg>
        </div>
      </div>
    </div>
  `,
})
export class ImageCompare {
  readonly orientation = input<ImageCompareOrientation>("horizontal");
  /** Divider position in percent, measured from the start (left or top). */
  readonly position = input(50, { transform: numberAttribute });
  /** Percent moved per arrow key press. */
  readonly step = input(5, { transform: numberAttribute });
  readonly beforeLabel = input("Before");
  readonly afterLabel = input("After");
  readonly sliderLabel = input("Comparison position");
  readonly ariaLabel = input<string>(undefined, { alias: "aria-label" });
  readonly userClass = input("", { alias: "class" });
  readonly positionChange = output<number>();

  protected readonly layer = layer;
  protected readonly handle = handle;
  protected readonly current = linkedSignal(() => clamp(this.position()));
  protected readonly rounded = computed(() => Math.round(this.current()));
  protected readonly dragging = signal(false);
  private readonly o = computed(() => orientations[this.orientation()]);
  protected readonly classes = computed(() =>
    cx(root, this.o().root, this.userClass()),
  );
  protected readonly afterClass = computed(() => cx(label, this.o().after));
  protected readonly beforeClass = computed(() => cx(label, this.o().before));
  protected readonly clipClass = computed(() =>
    cx(layer, this.o().clip, motion),
  );
  protected readonly dividerClass = computed(() =>
    cx(divider, this.o().divider, motion),
  );
  protected readonly iconClasses = computed(() => cx(iconClass, this.o().icon));
  private readonly handleEl =
    viewChild.required<ElementRef<HTMLDivElement>>("handleEl");
  private pressed = false;

  private move(next: number) {
    const value = clamp(next);
    this.current.set(value);
    this.positionChange.emit(value);
  }

  private fromPointer(event: PointerEvent) {
    const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
    this.move(
      this.orientation() === "vertical"
        ? ((event.clientY - rect.top) / rect.height) * 100
        : ((event.clientX - rect.left) / rect.width) * 100,
    );
  }

  protected onPointerDown(event: PointerEvent) {
    if (event.button !== 0) return;
    event.preventDefault();
    this.pressed = true;
    this.handleEl().nativeElement.focus({ preventScroll: true });
    (event.currentTarget as HTMLElement).setPointerCapture?.(event.pointerId);
    this.fromPointer(event);
  }

  protected onPointerMove(event: PointerEvent) {
    if (!this.pressed) return;
    this.dragging.set(true);
    this.fromPointer(event);
  }

  protected release() {
    this.pressed = false;
    this.dragging.set(false);
  }

  protected onKeyDown(event: KeyboardEvent) {
    const flip = this.orientation() === "vertical" ? -1 : 1;
    const at = this.current();
    const step = this.step();
    const moves: Record<string, number> = {
      ArrowRight: at + step,
      ArrowLeft: at - step,
      ArrowUp: at + step * flip,
      ArrowDown: at - step * flip,
      PageUp: at + PAGE_STEP,
      PageDown: at - PAGE_STEP,
      Home: 0,
      End: 100,
    };
    const next = moves[event.key];
    if (next === undefined) return;
    event.preventDefault();
    this.move(next);
  }
}
```

```ts
import { Component, signal } from "@angular/core";
import { ImageCompare } from "./markas/image-compare.component";

@Component({
  selector: "app-renovation",
  imports: [ImageCompare],
  template: `
    <markas-image-compare
      [(position)]="position"
      aria-label="Kitchen renovation"
    >
      <img before src="/img/kitchen-old.webp" alt="" />
      <img after src="/img/kitchen-new.webp" alt="" />
    </markas-image-compare>
  `,
})
export class Renovation {
  readonly position = signal(50);
}
```

## Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `before / after` | `ReactNode / slot` | - | The two views. Before sits on the start side (left or top), after on the end side. Both fill the same box, so give them the same size. |
| `orientation` | `'horizontal' \| 'vertical'` | horizontal | Horizontal splits left and right with a vertical divider. Vertical splits top and bottom. |
| `position / defaultPosition / v-model:position` | `number` | 50 | Starting divider position in percent from the start side. Blade uses position, React uses defaultPosition with onPositionChange, Vue uses v-model:position. |
| `step` | `number` | 5 | Percent moved per arrow key press. Page Up and Page Down move 10. |
| `beforeLabel` | `string` | Before | Text of the chip on the before side. |
| `afterLabel` | `string` | After | Text of the chip on the after side. |
| `sliderLabel` | `string` | Comparison position | Accessible name of the divider handle. |
| `positionChange` | `output<number>` | - | Angular only. Emits the new position in percent; supports [(position)]. Svelte uses bind:position or onPositionChange, Astro dispatches position-change. |

## Accessibility

- The handle is a focusable role slider with aria-valuenow, aria-valuetext in percent, and aria-orientation.
- Arrow keys move by step, Page Up and Page Down by 10, Home and End jump to either edge.
- Pressing anywhere on the image moves the divider there and focuses the handle, so the keyboard can take over.
- The divider glides to a clicked spot; with reduced motion it jumps there instead.

## Notes

- Before sits on the left (or top with `orientation="vertical"`), after on the right (or bottom). Give both the same size.
- Drag anywhere, click a spot, or focus the handle and use the arrow keys, Page Up/Down, Home, and End.
- Any content works: img, picture, svg, or plain markup such as an old and a new UI.
- Attributes and `class` go to the outer element.
