@esportsplus/ui 0.56.4 → 0.57.0

package/build/components/editor/code/layout.js

@@ -0,0 +1,350 @@
+import { clamp } from '../../../shared/clamp.js';
+import { floorIndex, lineStarts } from './document.js';
+const BREAK_NEVER_AFTER = new Set([36, 39, 40, 47, 60, 64, 91, 94, 95, 96, 123, 127]);
+const BREAK_NEVER_BEFORE = new Set([33, 41, 44, 46, 47, 58, 59, 63, 93, 125]);
+const BREAK_OPENERS = new Set([40, 60, 91, 123]);
+const EPSILON = 1 / 64;
+const LIMIT = 20000;
+const NONE = [];
+const WIDE = [
+    0x1100, 0x115f,
+    0x2e80, 0xa4cf,
+    0xac00, 0xd7a3,
+    0xd800, 0xdbff,
+    0xf900, 0xfaff,
+    0xfe30, 0xfe4f,
+    0xff00, 0xff60
+];
+function alphanumeric(code) {
+    return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function breakable(before, a, b) {
+    if (a === 45) {
+        if (b >= 48 && b <= 57) {
+            return alphanumeric(before);
+        }
+        return b !== 36 && !BREAK_NEVER_BEFORE.has(b);
+    }
+    if (alphanumeric(a) || BREAK_NEVER_AFTER.has(a) || a > 127) {
+        return false;
+    }
+    if (BREAK_NEVER_BEFORE.has(b)) {
+        return false;
+    }
+    if (a === 63) {
+        return b !== 34 && b !== 39;
+    }
+    return BREAK_OPENERS.has(b);
+}
+function columns(code) {
+    if (code < 0x1100) {
+        return 1;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) {
+        return 0;
+    }
+    for (let i = 0, n = WIDE.length; i < n; i += 2) {
+        if (code >= WIDE[i] && code <= WIDE[i + 1]) {
+            return 2;
+        }
+    }
+    return 1;
+}
+function irregular(text) {
+    for (let i = 0, n = text.length; i < n; i++) {
+        let code = text.charCodeAt(i);
+        if (code > 0xff || (code < 32 && code !== 9)) {
+            return true;
+        }
+    }
+    return false;
+}
+function wrap(text, width, charWidth, tabSize) {
+    let breaks, last = -1, row = 0, x = 0;
+    for (let i = 0, n = text.length; i < n; i++) {
+        let code = text.charCodeAt(i);
+        if (code === 32 || code === 9) {
+            x += code === 9 ? (tabSize - (Math.round(x / charWidth) % tabSize)) * charWidth : charWidth;
+            continue;
+        }
+        let span = columns(code), advance = span * charWidth, previous = i > row ? text.charCodeAt(i - 1) : -1;
+        if (previous === 32 ||
+            previous === 9 ||
+            (previous > 32 && breakable(i > 1 ? text.charCodeAt(i - 2) : 0, previous, code)) ||
+            (previous > 0x2e7f && span === 2)) {
+            last = i;
+        }
+        if (i > row && x + advance > width + EPSILON) {
+            row = last > row ? last : i;
+            x = 0;
+            for (let j = row; j < i; j++) {
+                x += columns(text.charCodeAt(j)) * charWidth;
+            }
+            (breaks ??= []).push(row);
+            last = -1;
+            if (x + advance > width + EPSILON && i > row) {
+                row = i;
+                x = 0;
+                breaks.push(row);
+            }
+        }
+        x += advance;
+    }
+    return breaks ?? NONE;
+}
+class EditorLayout {
+    charWidth;
+    lineHeight;
+    tabSize;
+    width;
+    wrap;
+    breaks = [];
+    cache;
+    estimates = new Set();
+    folded;
+    numbers = null;
+    projection;
+    source;
+    starts;
+    total = 0;
+    tree = [];
+    constructor(projection, source, width, lineHeight, charWidth, tabSize, wrap, cache = new Map()) {
+        this.cache = cache;
+        this.charWidth = charWidth;
+        this.folded = projection.placeholders().length > 0;
+        this.lineHeight = lineHeight;
+        this.projection = projection;
+        this.source = source;
+        this.starts = lineStarts(projection.value);
+        this.tabSize = tabSize;
+        this.width = width;
+        this.wrap = wrap;
+        if (wrap) {
+            for (let i = 0, n = this.starts.length; i < n; i++) {
+                this.breaks.push(this.compute(i));
+            }
+            this.index();
+        }
+    }
+    compute(index) {
+        let text = this.text(index), widest = text.length * this.charWidth;
+        if (irregular(text)) {
+            this.estimates.add(index);
+            widest *= 2;
+        }
+        if (widest * (text.indexOf('\t') < 0 ? 1 : this.tabSize) <= this.width) {
+            return NONE;
+        }
+        let cached = this.cache.get(text);
+        if (cached) {
+            return cached;
+        }
+        let breaks = wrap(text, this.width, this.charWidth, this.tabSize);
+        if (this.cache.size >= LIMIT) {
+            this.cache.delete(this.cache.keys().next().value);
+        }
+        this.cache.set(text, breaks);
+        return breaks;
+    }
+    index() {
+        let breaks = this.breaks, n = breaks.length, tree = new Array(n + 1).fill(0), total = 0;
+        for (let i = 1; i <= n; i++) {
+            let rows = breaks[i - 1].length + 1;
+            total += rows;
+            tree[i] += rows;
+            let parent = i + (i & -i);
+            if (parent <= n) {
+                tree[parent] += tree[i];
+            }
+        }
+        this.total = total;
+        this.tree = tree;
+    }
+    row(index, offset) {
+        let breaks = this.breaks[index] ?? NONE, local = offset - this.starts[index];
+        return breaks.length ? floorIndex(breaks, local) + 1 : 0;
+    }
+    rowsBefore(index) {
+        if (!this.wrap) {
+            return index;
+        }
+        let sum = 0, tree = this.tree;
+        for (let i = index; i > 0; i -= i & -i) {
+            sum += tree[i];
+        }
+        return sum;
+    }
+    segment(index, row) {
+        let breaks = this.breaks[index] ?? NONE, from = this.starts[index];
+        return {
+            from: row ? from + breaks[row - 1] : from,
+            to: row < breaks.length ? from + breaks[row] : this.end(index)
+        };
+    }
+    text(index) {
+        return this.projection.value.slice(this.starts[index], this.end(index));
+    }
+    get count() {
+        return this.starts.length;
+    }
+    get height() {
+        return (this.wrap ? this.total : this.starts.length) * this.lineHeight;
+    }
+    get lines() {
+        let out = [];
+        for (let i = 0, n = this.starts.length; i < n; i++) {
+            let breaks = [this.starts[i]];
+            for (let b of this.breaks[i] ?? NONE) {
+                breaks.push(this.starts[i] + b);
+            }
+            out.push({
+                breaks,
+                from: this.starts[i],
+                height: this.rows(i) * this.lineHeight,
+                number: this.number(i),
+                to: this.end(i),
+                top: this.top(i)
+            });
+        }
+        return out;
+    }
+    breaksOf(index) {
+        return this.breaks[index] ?? NONE;
+    }
+    estimated(index) {
+        return this.estimates.has(index);
+    }
+    edit(projection, from, to, end) {
+        let starts = this.starts, first = Math.max(0, floorIndex(starts, from)), last = Math.max(first, floorIndex(starts, to)), text = projection.value, delta = end - to, added = [];
+        this.folded = projection.placeholders().length > 0;
+        this.numbers = null;
+        this.projection = projection;
+        for (let p = text.indexOf('\n', starts[first]); p >= 0 && p < end; p = text.indexOf('\n', p + 1)) {
+            added.push(p + 1);
+        }
+        let next = starts.slice(0, first + 1);
+        for (let i = 0, n = added.length; i < n; i++) {
+            next.push(added[i]);
+        }
+        for (let i = last + 1, n = starts.length; i < n; i++) {
+            next.push(starts[i] + delta);
+        }
+        let inserted = added.length + 1, removed = last - first + 1;
+        this.starts = next;
+        if (!this.wrap) {
+            return { first, inserted, removed };
+        }
+        if (this.estimates.size) {
+            let estimates = new Set();
+            for (let i of this.estimates) {
+                if (i < first) {
+                    estimates.add(i);
+                }
+                else if (i > last) {
+                    estimates.add(i + inserted - removed);
+                }
+            }
+            this.estimates = estimates;
+        }
+        let breaks = [];
+        for (let i = first, n = first + inserted; i < n; i++) {
+            breaks.push(this.compute(i));
+        }
+        this.breaks.splice(first, removed, ...breaks);
+        this.index();
+        return { first, inserted, removed };
+    }
+    end(index) {
+        let next = this.starts[index + 1];
+        return next === undefined ? this.projection.value.length : next - 1;
+    }
+    indexAt(y) {
+        let n = this.starts.length;
+        if (!this.wrap) {
+            return clamp(Math.floor(y / this.lineHeight), 0, n - 1);
+        }
+        let target = Math.floor(Math.max(0, y) / this.lineHeight), index = 0, tree = this.tree;
+        for (let step = 1 << Math.floor(Math.log2(n || 1)); step > 0; step >>= 1) {
+            let next = index + step;
+            if (next <= n && tree[next] <= target) {
+                index = next;
+                target -= tree[next];
+            }
+        }
+        return Math.min(index, n - 1);
+    }
+    lineAt(offset) {
+        return Math.max(0, floorIndex(this.starts, offset));
+    }
+    lineFrom(index) {
+        return this.starts[index];
+    }
+    measure(index, breaks) {
+        this.estimates.delete(index);
+        if (!this.wrap) {
+            return false;
+        }
+        let previous = this.breaks[index] ?? NONE, same = previous.length === breaks.length;
+        for (let i = 0; same && i < breaks.length; i++) {
+            same = previous[i] === breaks[i];
+        }
+        if (same) {
+            return false;
+        }
+        this.breaks[index] = breaks.length ? breaks : NONE;
+        if (previous.length === breaks.length) {
+            return false;
+        }
+        this.index();
+        return true;
+    }
+    number(index) {
+        if (!this.folded) {
+            return index + 1;
+        }
+        let numbers = this.numbers;
+        if (!numbers) {
+            let source = typeof this.source === 'string' ? lineStarts(this.source) : this.source.starts;
+            numbers = this.numbers = [];
+            for (let i = 0, n = this.starts.length; i < n; i++) {
+                numbers.push(floorIndex(source, this.projection.toSource(this.starts[i])) + 1);
+            }
+        }
+        return numbers[index];
+    }
+    offset(x, y) {
+        let index = this.indexAt(y), rows = this.rows(index), row = clamp(Math.floor((y - this.top(index)) / this.lineHeight), 0, rows - 1), { from, to } = this.segment(index, row), text = this.projection.value, left = 0;
+        for (let i = from; i < to; i++) {
+            let code = text.charCodeAt(i), advance = code === 9
+                ? (this.tabSize - (Math.round(left / this.charWidth) % this.tabSize)) * this.charWidth
+                : columns(code) * this.charWidth;
+            if (x < left + advance / 2) {
+                return i;
+            }
+            left += advance;
+        }
+        return row < rows - 1 && to > from ? to - 1 : to;
+    }
+    rect(offset) {
+        offset = clamp(offset, 0, this.projection.value.length);
+        let index = this.lineAt(offset), row = this.row(index, offset), { from } = this.segment(index, row), text = this.projection.value, left = 0;
+        for (let i = from; i < offset; i++) {
+            let code = text.charCodeAt(i);
+            left += code === 9
+                ? (this.tabSize - (Math.round(left / this.charWidth) % this.tabSize)) * this.charWidth
+                : columns(code) * this.charWidth;
+        }
+        return { height: this.lineHeight, left, top: this.top(index) + row * this.lineHeight, width: 1 };
+    }
+    rows(index) {
+        return (this.breaks[index]?.length ?? 0) + 1;
+    }
+    top(index) {
+        return this.rowsBefore(index) * this.lineHeight;
+    }
+    visible(top, bottom) {
+        let first = this.indexAt(top), last = this.indexAt(Math.max(top, bottom - 1));
+        return { first, last: last + 1 };
+    }
+}
+export { EditorLayout, irregular };

package/build/components/editor/code/links.d.ts

@@ -0,0 +1,8 @@
+type Link = {
+    from: number;
+    to: number;
+    url: string;
+};
+declare const linksIn: (text: string, local: boolean) => Link[];
+export { linksIn };
+export type { Link };

package/build/components/editor/code/links.js

@@ -0,0 +1,32 @@
+const PATH = /(?<![\w./-])\.{1,2}\/[\w@.~+/-]*[\w@~+/-]/g;
+const TRAILING = /[.,;:!?'"]+$/;
+const URL_PATTERN = /\b(?:https?:\/\/|file:\/\/)[^\s<>"'`]+/gi;
+const linksIn = (text, local) => {
+    let out = [];
+    if (text.indexOf('://') !== -1) {
+        URL_PATTERN.lastIndex = 0;
+        for (let match = URL_PATTERN.exec(text); match; match = URL_PATTERN.exec(text)) {
+            let url = match[0].replace(TRAILING, '');
+            for (let [open, close] of [['(', ')'], ['[', ']'], ['{', '}']]) {
+                while (url.endsWith(close) && url.split(open).length < url.split(close).length) {
+                    url = url.slice(0, -1).replace(TRAILING, '');
+                }
+            }
+            if (!local && url.slice(0, 7).toLowerCase() === 'file://') {
+                continue;
+            }
+            out.push({ from: match.index, to: match.index + url.length, url });
+        }
+    }
+    if (local && text.indexOf('./') !== -1) {
+        PATH.lastIndex = 0;
+        for (let match = PATH.exec(text); match; match = PATH.exec(text)) {
+            let at = match.index;
+            if (!out.some((link) => at >= link.from && at < link.to)) {
+                out.push({ from: at, to: at + match[0].length, url: match[0] });
+            }
+        }
+    }
+    return out.sort((a, b) => a.from - b.from);
+};
+export { linksIn };

package/build/components/editor/code/minimap.d.ts

@@ -0,0 +1,46 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { type Attributes } from '@esportsplus/template';
+import type { Token } from './syntax.js';
+declare class ReactiveObject_0bg9uqd0 extends reactivity_u0.ReactiveObject<any> {
+    #private;
+    constructor();
+    get height(): number;
+    set height(_v0: number);
+    get top(): number;
+    set top(_v1: number);
+}
+type Source = {
+    breaks: (index: number) => readonly number[];
+    count: number;
+    height: number;
+    indexAt: (y: number) => number;
+    lineHeight: number;
+    rows: (index: number) => number;
+    tabSize: number;
+    text: (index: number) => string;
+    tokens: (index: number) => readonly Token[];
+    top: (index: number) => number;
+};
+type Viewport = {
+    clientHeight: number;
+    scrollHeight: number;
+    scrollTop: number;
+};
+declare const minimapMetrics: (height: number, scrollHeight: number, clientHeight: number, scrollTop: number) => {
+    height: number;
+    scroll: number;
+    top: number;
+    travel: number;
+};
+declare const minimapScroll: (y: number, grab: number, height: number, scrollHeight: number, clientHeight: number) => number;
+declare const minimap: ({ focus, scroll }: {
+    focus: VoidFunction;
+    scroll: (top: number, relative: boolean) => void;
+}) => {
+    invalidate: (first?: number | null, last?: number) => void;
+    paint: (source: Source, view: Viewport, palette: Record<string, string>, size: number) => void;
+    state: ReactiveObject_0bg9uqd0;
+    template: (attributes?: Attributes) => DocumentFragment | Text;
+};
+export { minimap, minimapMetrics, minimapScroll };
+export type { Source, Viewport };

package/build/components/editor/code/minimap.js

@@ -0,0 +1,172 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import * as template_u1 from '@esportsplus/template';
+import { clamp } from '../../../shared/clamp.js';
+const template_0bg9uqd2 = template_u1.template(`<div aria-hidden='true' class='code-editor-minimap'><canvas class='code-editor-minimap-canvas'></canvas><div class='code-editor-minimap-slider'>`);
+class ReactiveObject_0bg9uqd0 extends reactivity_u0.ReactiveObject {
+    #height = this[reactivity_u0.SIGNAL](24);
+    #top = this[reactivity_u0.SIGNAL](0);
+    constructor() {
+        super(null);
+    }
+    get height() {
+        return reactivity_u0.read(this.#height);
+    }
+    set height(_v0) {
+        reactivity_u0.write(this.#height, _v0);
+    }
+    get top() {
+        return reactivity_u0.read(this.#top);
+    }
+    set top(_v1) {
+        reactivity_u0.write(this.#top, _v1);
+    }
+}
+const COLUMNS = 70;
+const INSET = 3;
+const LONG = 10000;
+const PITCH = 4;
+const SPACING = 1.15;
+function blank(text, i) {
+    let code = text.charCodeAt(i);
+    return code === 32 || code === 9 || code === 160;
+}
+const minimapMetrics = (height, scrollHeight, clientHeight, scrollTop) => {
+    let slider = Math.min(height, Math.max(24, (height * clientHeight) / Math.max(1, scrollHeight))), travel = Math.max(0, height - slider), scroll = Math.max(0, scrollHeight - clientHeight);
+    return {
+        height: slider,
+        scroll,
+        top: scroll ? clamp((scrollTop / scroll) * travel, 0, travel) : 0,
+        travel
+    };
+};
+const minimapScroll = (y, grab, height, scrollHeight, clientHeight) => {
+    let metrics = minimapMetrics(height, scrollHeight, clientHeight, 0);
+    return metrics.travel ? (clamp(y - grab, 0, metrics.travel) / metrics.travel) * metrics.scroll : 0;
+};
+const minimap = ({ focus, scroll }) => {
+    let canvas, colors = {}, content = 0, dirty = null, full = true, grab = null, lineHeight = 20, pixels = '', state = new ReactiveObject_0bg9uqd0(), style = '', viewport = { clientHeight: 0, scrollHeight: 0, scrollTop: 0 }, width = 0;
+    function draw(context, source, scale, index) {
+        let text = source.text(index), top = source.top(index), pitch = Math.max(1, Math.min(3, source.lineHeight * scale));
+        if (text.length > LONG) {
+            fill(context, colors.comment);
+            context.fillRect(INSET, top * scale, Math.min(width - INSET * 2, COLUMNS), pitch);
+            return;
+        }
+        let breaks = source.breaks(index), tokens = source.tokens(index), t = 0;
+        for (let row = 0, rows = breaks.length + 1; row < rows; row++) {
+            let from = row ? breaks[row - 1] : 0, to = Math.min(row < breaks.length ? breaks[row] : text.length, from + COLUMNS), x = INSET, y = (top + row * source.lineHeight) * scale;
+            for (let i = from; i < to;) {
+                if (blank(text, i)) {
+                    x += text.charCodeAt(i) === 9 ? source.tabSize * SPACING : SPACING;
+                    i++;
+                    continue;
+                }
+                while (t < tokens.length && tokens[t].to <= i) {
+                    t++;
+                }
+                let token = tokens[t], kind = token && token.from <= i ? token.kind : 'variable', end = Math.min(to, token ? (token.from <= i ? token.to : token.from) : to), start = x;
+                while (i < end && !blank(text, i)) {
+                    x += SPACING;
+                    i++;
+                }
+                fill(context, colors[kind] ?? colors.variable);
+                context.fillRect(start, y, x - start, pitch);
+            }
+        }
+    }
+    function fill(context, color) {
+        if (color !== style) {
+            context.fillStyle = style = color;
+        }
+    }
+    function move(e) {
+        if (grab === null || !canvas) {
+            return;
+        }
+        scroll(minimapScroll(e.clientY - canvas.getBoundingClientRect().top, grab, content, viewport.scrollHeight, viewport.clientHeight), false);
+    }
+    function release() {
+        grab = null;
+    }
+    let handlers = {
+        onactivewheel: (e) => {
+            e.preventDefault();
+            scroll(e.deltaY * (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? viewport.clientHeight : 1), true);
+        },
+        onlostpointercapture: release,
+        onpointercancel: release,
+        onpointerdown: (e) => {
+            if (e.button !== 0 || !canvas) {
+                return;
+            }
+            let y = e.clientY - canvas.getBoundingClientRect().top;
+            e.preventDefault();
+            focus();
+            grab = y >= state.top && y <= state.top + state.height ? y - state.top : state.height / 2;
+            e.currentTarget.setPointerCapture(e.pointerId);
+            move(e);
+        },
+        onpointermove: move,
+        onpointerup: release
+    };
+    return {
+        invalidate: (first = null, last = first ?? 0) => {
+            if (first === null) {
+                full = true;
+                return;
+            }
+            dirty = dirty ? [Math.min(dirty[0], first), Math.max(dirty[1], last)] : [first, last];
+        },
+        paint: (source, view, palette, size) => {
+            let height = view.clientHeight, ratio = devicePixelRatio || 1, context = canvas?.getContext('2d');
+            lineHeight = source.lineHeight;
+            viewport = view;
+            content = Math.min(height, Math.max(1, source.height / source.lineHeight) * PITCH);
+            let metrics = minimapMetrics(content, view.scrollHeight, height, view.scrollTop);
+            state.height = metrics.height;
+            state.top = metrics.top;
+            if (!canvas || !context || !height || !size) {
+                return;
+            }
+            let key = `${size}:${height}:${ratio}:${content}:${source.height}`;
+            if (key !== pixels || colors !== palette) {
+                canvas.height = Math.round(height * ratio);
+                canvas.width = Math.round(size * ratio);
+                colors = palette;
+                full = true;
+                pixels = key;
+                width = size;
+            }
+            if (!full && !dirty) {
+                return;
+            }
+            let scale = content / Math.max(1, source.height), step = Math.max(1, Math.ceil(source.count / Math.max(1, height))), first = 0, last = source.count;
+            context.setTransform(ratio, 0, 0, ratio, 0, 0);
+            style = '';
+            if (full) {
+                context.clearRect(0, 0, width, height);
+            }
+            else {
+                let [a, b] = dirty, y0 = Math.floor(source.top(a) * scale), y1 = Math.ceil((source.top(b - 1) + source.rows(b - 1) * source.lineHeight) * scale) + 1;
+                context.clearRect(0, y0, width, y1 - y0);
+                first = source.indexAt(y0 / scale);
+                last = Math.min(source.count, source.indexAt(y1 / scale) + 1);
+            }
+            for (let index = first - (first % step); index < last; index += step) {
+                draw(context, source, scale, index);
+            }
+            dirty = null;
+            full = false;
+        },
+        state,
+        template: (attributes) => {
+            let root_0bg9uqd1 = template_0bg9uqd2(), element_0bg9uqd3 = root_0bg9uqd1.firstChild, element_0bg9uqd4 = element_0bg9uqd3.firstElementChild, element_0bg9uqd5 = element_0bg9uqd4.nextElementSibling;
+            template_u1.setList(element_0bg9uqd5, 'style', () => `--slider-height: ${state.height}px; --slider-top: ${state.top}px;`);
+            template_u1.onconnect(element_0bg9uqd4, (element) => { canvas = element; });
+            template_u1.setProperties(element_0bg9uqd3, handlers);
+            template_u1.setProperties(element_0bg9uqd3, attributes);
+            return root_0bg9uqd1;
+        }
+    };
+};
+export { minimap, minimapMetrics, minimapScroll };

package/build/components/editor/code/navigation.d.ts

@@ -0,0 +1,17 @@
+import type { EditorDocument } from './document.js';
+import type { EditorLayout } from './layout.js';
+import type { NativeText } from './projection.js';
+type Move = {
+    boundary?: boolean;
+    extend: boolean;
+    goals: number[];
+    key: string;
+    page: number;
+    word?: boolean;
+};
+declare const move: (document: EditorDocument, layout: EditorLayout, projection: NativeText, lineHeight: number, { boundary, extend, goals, key, page, word }: Move) => Partial<Readonly<{
+    direction: 'backward' | 'forward' | 'none';
+    end: number;
+    start: number;
+}>>[];
+export { move };

package/build/components/editor/code/navigation.js

@@ -0,0 +1,49 @@
+import { stepCharacter } from './selection.js';
+const WORD_BACKWARD = /(?:\s+|[\w$]+|[^\w\s$]+)$/;
+const WORD_FORWARD = /^(?:\s+|[\w$]+|[^\w\s$]+)/;
+const WORD_WINDOW = 1000;
+const move = (document, layout, projection, lineHeight, { boundary, extend, goals, key, page, word }) => {
+    let value = document.value;
+    return document.selections.map((range, index) => {
+        let anchor = range.direction === 'backward' ? range.end : range.start, head = range.direction === 'backward' ? range.start : range.end, next = head, rect = layout.rect(projection.toNative(head));
+        if (boundary && (key === 'Home' || key === 'ArrowUp')) {
+            next = 0;
+        }
+        else if (boundary && (key === 'End' || key === 'ArrowDown')) {
+            next = value.length;
+        }
+        else if (key === 'ArrowLeft' || key === 'ArrowRight') {
+            let backward = key === 'ArrowLeft';
+            if (!extend && range.start !== range.end) {
+                next = backward ? range.start : range.end;
+            }
+            else if (word && backward) {
+                next = head - (WORD_BACKWARD.exec(value.slice(Math.max(0, head - WORD_WINDOW), head))?.[0].length ?? 0);
+            }
+            else if (word) {
+                next = head + (WORD_FORWARD.exec(value.slice(head, head + WORD_WINDOW))?.[0].length ?? 0);
+            }
+            else {
+                next = stepCharacter(value, head, backward);
+            }
+        }
+        else if (key === 'Home' || key === 'End') {
+            let at = layout.offset(key === 'Home' ? 0 : Number.MAX_SAFE_INTEGER, rect.top + lineHeight / 2);
+            if (key === 'Home') {
+                let indented = at + /^[\t ]*/.exec(projection.value.slice(at, layout.end(layout.lineAt(at))))[0].length;
+                at = projection.toNative(head) === indented ? at : indented;
+            }
+            next = projection.toSource(at);
+        }
+        else {
+            let delta = (key === 'ArrowUp' || key === 'PageUp' ? -1 : 1) * (key.startsWith('Page') ? page : lineHeight), x = goals[index] ?? rect.left;
+            goals[index] = x;
+            next = projection.toSource(layout.offset(x, rect.top + delta + lineHeight / 2));
+        }
+        if (!extend) {
+            return { start: next };
+        }
+        return { direction: next < anchor ? 'backward' : 'forward', end: Math.max(anchor, next), start: Math.min(anchor, next) };
+    });
+};
+export { move };