@celljs/ta-web 0.0.0-stage → 4.6.1

package/src/browser/util/frame.spec.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test';
+import { type FrameScheduler, FrameUtil } from './frame';
+
+function frames(): FrameScheduler & { run(): void; pending(): number } {
+    const callbacks = new Map<number, () => void>();
+    let next = 1;
+    return {
+        request: callback => {
+            callbacks.set(next, callback);
+            return next++;
+        },
+        cancel: handle => void callbacks.delete(handle),
+        run: () => {
+            const due = [...callbacks.values()];
+            callbacks.clear();
+            for (const callback of due) {
+                callback();
+            }
+        },
+        pending: () => callbacks.size,
+    };
+}
+
+describe('FrameUtil', () => {
+    it('calls the listener once a frame, however often it is asked to', () => {
+        const scheduler = frames();
+        let calls = 0;
+        const { call } = FrameUtil.coalesce(() => calls++, scheduler);
+        call();
+        call();
+        call();
+        expect(scheduler.pending()).toBe(1);
+        scheduler.run();
+        expect(calls).toBe(1);
+        call();
+        scheduler.run();
+        expect(calls).toBe(2);
+    });
+
+    it('drops a call not made yet when cancelled', () => {
+        const scheduler = frames();
+        let calls = 0;
+        const { call, cancel } = FrameUtil.coalesce(() => calls++, scheduler);
+        call();
+        cancel();
+        scheduler.run();
+        expect(calls).toBe(0);
+        call();
+        scheduler.run();
+        expect(calls).toBe(1);
+    });
+
+    it('tells whether a view is at its bottom', () => {
+        expect(FrameUtil.atBottom({ scrollHeight: 1000, scrollTop: 600, clientHeight: 380 })).toBe(true);
+        expect(FrameUtil.atBottom({ scrollHeight: 1000, scrollTop: 400, clientHeight: 380 })).toBe(false);
+    });
+
+    it('brings a message to the top of the view, with the room below it that its answer will fill', () => {
+        expect(FrameUtil.anchor(500, 800)).toEqual({ top: 488, minHeight: 1288 });
+        expect(FrameUtil.anchor(4, 800)).toEqual({ top: 0, minHeight: 800 });
+    });
+});

package/src/browser/util/frame.ts

@@ -0,0 +1,54 @@
+/** What schedules a callback for the next frame, and cancels it: requestAnimationFrame in a page. */
+export interface FrameScheduler {
+    request(callback: () => void): number;
+    cancel(handle: number): void;
+}
+
+/** requestAnimationFrame; a timer of one frame where there is none (tests, workers). */
+const ANIMATION_FRAME: FrameScheduler =
+    typeof requestAnimationFrame === 'function'
+        ? { request: callback => requestAnimationFrame(callback), cancel: handle => cancelAnimationFrame(handle) }
+        : { request: callback => setTimeout(callback, 16) as unknown as number, cancel: handle => clearTimeout(handle) };
+
+export namespace FrameUtil {
+    /**
+     * The listener, called at most once a frame however often the returned function is: a store that
+     * changes many times between two frames costs one render. `cancel` drops a call not made yet.
+     */
+    export function coalesce(listener: () => void, scheduler: FrameScheduler = ANIMATION_FRAME): { call(): void; cancel(): void } {
+        let handle: number | undefined;
+        return {
+            call: () => {
+                handle ??= scheduler.request(() => {
+                    handle = undefined;
+                    listener();
+                });
+            },
+            cancel: () => {
+                if (handle !== undefined) {
+                    scheduler.cancel(handle);
+                    handle = undefined;
+                }
+            },
+        };
+    }
+
+    /** Below this distance from the bottom, the view follows what comes in. */
+    export const STICK_PX = 80;
+
+    export function atBottom(element: { scrollHeight: number; scrollTop: number; clientHeight: number }): boolean {
+        return element.scrollHeight - element.scrollTop - element.clientHeight < STICK_PX;
+    }
+
+    /** The room left above a message brought to the top of the view. */
+    export const ANCHOR_GAP = 12;
+
+    /**
+     * Where the view scrolls to show a message at its top (`offset`: from the top of the thread), and how
+     * tall the thread must be at least for it to get there while what answers it is still short.
+     */
+    export function anchor(offset: number, viewport: number, gap = ANCHOR_GAP): { top: number; minHeight: number } {
+        const top = Math.max(0, offset - gap);
+        return { top, minHeight: top + viewport };
+    }
+}

package/src/browser/util/layout.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'bun:test';
+import { LayoutUtil, type PaneSpec } from './layout';
+
+const SIDE: PaneSpec = { key: 'side', initial: 260, min: 200, max: 480 };
+
+describe('LayoutUtil', () => {
+    it('follows the drag within the bounds, on either side of the sash', () => {
+        expect(LayoutUtil.drag(260, 40, 'start', SIDE)).toEqual({ size: 300, collapsed: false });
+        expect(LayoutUtil.drag(260, 40, 'end', SIDE)).toEqual({ size: 220, collapsed: false });
+        expect(LayoutUtil.drag(260, 900, 'start', SIDE)).toEqual({ size: 480, collapsed: false });
+        expect(LayoutUtil.drag(260, -100, 'start', SIDE)).toEqual({ size: 200, collapsed: false });
+    });
+
+    it('collapses a pane dragged far below its minimum, keeping its width for when it opens again', () => {
+        expect(LayoutUtil.drag(300, -250, 'start', SIDE)).toEqual({ size: 300, collapsed: true });
+        expect(LayoutUtil.drag(300, 250, 'end', SIDE)).toEqual({ size: 300, collapsed: true });
+    });
+
+    it('moves the sash with arrow keys, and to the bounds with Home and End', () => {
+        expect(LayoutUtil.key(260, 'ArrowRight', false, 'start', SIDE)).toBe(276);
+        expect(LayoutUtil.key(260, 'ArrowRight', true, 'start', SIDE)).toBe(324);
+        expect(LayoutUtil.key(260, 'ArrowRight', false, 'end', SIDE)).toBe(244);
+        expect(LayoutUtil.key(210, 'ArrowLeft', true, 'start', SIDE)).toBe(200);
+        expect(LayoutUtil.key(260, 'Home', false, 'start', SIDE)).toBe(200);
+        expect(LayoutUtil.key(260, 'End', false, 'end', SIDE)).toBe(480);
+        expect(LayoutUtil.key(260, 'Enter', false, 'start', SIDE)).toBeUndefined();
+    });
+
+    it('keeps the width in this browser, and reads back only a width within the bounds', () => {
+        const spec = LayoutUtil.state(SIDE);
+        expect(spec).toMatchObject({ key: 'layout.side', tier: 'device', initial: { size: 260, collapsed: false } });
+        expect(spec.parse({ size: 333, collapsed: true })).toEqual({ size: 333, collapsed: true });
+        expect(spec.parse({ size: 9999 })).toEqual({ size: 480, collapsed: false });
+        expect(spec.parse('not json')).toBeUndefined();
+        expect(spec.parse(null)).toBeUndefined();
+    });
+});

package/src/browser/util/layout.ts

@@ -0,0 +1,71 @@
+import type { StateSpec } from '../state/state-protocol';
+
+/** A column of the page whose width the user drags. */
+export interface PaneSpec {
+    /** Its width is kept in this browser as `layout.<key>` (TaState, `device`). */
+    key: string;
+    initial: number;
+    min: number;
+    max: number;
+}
+
+export interface PaneState {
+    size: number;
+    collapsed: boolean;
+}
+
+/** `start`: the pane is before its sash, so dragging towards the end widens it. `end`: after it. */
+export type PaneSide = 'start' | 'end';
+
+/** Dragged narrower than this share of its minimum, a pane collapses. */
+const COLLAPSE_AT = 0.5;
+/** Pixels an arrow key moves a sash; with Shift, four times as many. */
+const STEP = 16;
+
+export namespace LayoutUtil {
+    export function clamp(size: number, spec: PaneSpec): number {
+        return Math.round(Math.min(spec.max, Math.max(spec.min, size)));
+    }
+
+    /** The pane after dragging its sash by `delta` pixels from where its width was `start`. */
+    export function drag(start: number, delta: number, side: PaneSide, spec: PaneSpec): PaneState {
+        const size = start + (side === 'start' ? delta : -delta);
+        if (size < spec.min * COLLAPSE_AT) {
+            return { size: clamp(start, spec), collapsed: true };
+        }
+        return { size: clamp(size, spec), collapsed: false };
+    }
+
+    /** The width after a key on the focused sash; undefined for a key that does not move it. */
+    export function key(size: number, key: string, shift: boolean, side: PaneSide, spec: PaneSpec): number | undefined {
+        const step = shift ? STEP * 4 : STEP;
+        const grow = side === 'start' ? 'ArrowRight' : 'ArrowLeft';
+        const shrink = side === 'start' ? 'ArrowLeft' : 'ArrowRight';
+        switch (key) {
+            case grow:
+                return clamp(size + step, spec);
+            case shrink:
+                return clamp(size - step, spec);
+            case 'Home':
+                return spec.min;
+            case 'End':
+                return spec.max;
+            default:
+                return undefined;
+        }
+    }
+
+    /** What was kept, within the bounds; undefined for what is not a width (not ours, or from an older version). */
+    export function parse(value: unknown, spec: PaneSpec): PaneState | undefined {
+        const stored = value as Partial<PaneState> | null | undefined;
+        if (stored && typeof stored === 'object' && typeof stored.size === 'number' && Number.isFinite(stored.size)) {
+            return { size: clamp(stored.size, spec), collapsed: stored.collapsed === true };
+        }
+        return undefined;
+    }
+
+    /** Where the width of the pane is kept: in this browser, which has its own screen. */
+    export function state(spec: PaneSpec): StateSpec<PaneState> {
+        return { key: `layout.${spec.key}`, tier: 'device', initial: { size: spec.initial, collapsed: false }, parse: value => parse(value, spec) };
+    }
+}

package/src/browser/util/link.spec.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'bun:test';
+import { LinkUtil } from './link';
+
+describe('LinkUtil', () => {
+    it('reads pages of the web, and no other scheme', () => {
+        expect(LinkUtil.parse('https://x.dev/a?b=1#c')).toEqual({ type: 'url', url: 'https://x.dev/a?b=1#c' });
+        expect(LinkUtil.parse('mailto:a@b.dev')).toEqual({ type: 'mail', url: 'mailto:a@b.dev' });
+        for (const target of [
+            'javascript:alert(1)',
+            'JaVaScRiPt:x',
+            'data:text/html,hi',
+            'vbscript:x',
+            'command:workbench.action.reload',
+            'vscode://x',
+            '//evil.dev/a',
+            'file://host/etc/passwd',
+            'mailto:',
+        ]) {
+            expect(LinkUtil.parse(target)).toBeUndefined();
+        }
+    });
+
+    it('reads paths with the lines they point to, as VS Code does', () => {
+        expect(LinkUtil.parse('src/a.ts')).toEqual({ type: 'path', path: 'src/a.ts' });
+        expect(LinkUtil.parse('src/a.ts#L10')).toEqual({ type: 'path', path: 'src/a.ts', selection: { startLine: 10 } });
+        expect(LinkUtil.parse('src/a.ts#L10C5-L12C3')).toEqual({
+            type: 'path',
+            path: 'src/a.ts',
+            selection: { startLine: 10, startColumn: 5, endLine: 12, endColumn: 3 },
+        });
+        expect(LinkUtil.parse('src/a.ts#L10-L20')).toMatchObject({ selection: { startLine: 10, endLine: 20 } });
+        expect(LinkUtil.parse('src/a.ts#10,4')).toMatchObject({ selection: { startLine: 10, startColumn: 4 } });
+        expect(LinkUtil.parse('src/a.ts:42')).toEqual({ type: 'path', path: 'src/a.ts', selection: { startLine: 42 } });
+        expect(LinkUtil.parse('src/a.ts:42:7')).toMatchObject({ path: 'src/a.ts', selection: { startLine: 42, startColumn: 7 } });
+        expect(LinkUtil.parse('src/a.ts:10-20')).toMatchObject({ selection: { startLine: 10, endLine: 20 } });
+        // An end before the start is no range.
+        expect(LinkUtil.parse('a.ts:20-10')).toMatchObject({ selection: { startLine: 20 } });
+        expect(LinkUtil.parse('file:///Users/me/a%20b.ts#L3')).toEqual({ type: 'path', path: '/Users/me/a b.ts', selection: { startLine: 3 } });
+        expect(LinkUtil.parse('docs/')).toEqual({ type: 'path', path: 'docs', directory: true });
+        expect(LinkUtil.parse('C:/repo/a.ts')).toMatchObject({ type: 'path', path: 'C:/repo/a.ts' });
+        expect(LinkUtil.parse('README.md#usage')).toEqual({ type: 'path', path: 'README.md' });
+    });
+
+    it('takes code spans that name files, not code', () => {
+        expect(LinkUtil.codeReference('src/app.ts:12')).toMatchObject({ path: 'src/app.ts', selection: { startLine: 12 } });
+        expect(LinkUtil.codeReference('package.json')).toMatchObject({ path: 'package.json' });
+        expect(LinkUtil.codeReference('./lib/a.foo')).toMatchObject({ path: './lib/a.foo' });
+        expect(LinkUtil.codeReference('docs/')).toMatchObject({ path: 'docs', directory: true });
+        for (const code of [
+            'console.log',
+            'a.b.c',
+            'process.env',
+            'text/html',
+            '@celljs/core',
+            'npm test',
+            'foo',
+            'Node.js',
+            'https://x.dev',
+            'v1.2',
+            '/',
+            'a.ts && b',
+        ]) {
+            expect(LinkUtil.codeReference(code)).toBeUndefined();
+        }
+    });
+
+    it('finds URLs in text, without the punctuation that ends a sentence', () => {
+        expect(LinkUtil.bareUrl('https://x.dev/a.')).toBe('https://x.dev/a');
+        expect(LinkUtil.bareUrl('https://x.dev/a，然后')).toBe('https://x.dev/a');
+        expect(LinkUtil.bareUrl('https://x.dev/a) and')).toBe('https://x.dev/a');
+        expect(LinkUtil.bareUrl('https://en.wikipedia.org/wiki/A_(b) and')).toBe('https://en.wikipedia.org/wiki/A_(b)');
+        expect(LinkUtil.bareUrl('http://localhost:5173/')).toBe('http://localhost:5173/');
+        expect(LinkUtil.bareUrl('https://')).toBeUndefined();
+    });
+
+    it('resolves paths against the directory of the conversation', () => {
+        expect(LinkUtil.resolve('/repo', 'src/a.ts')).toEqual({ cwd: '/repo', path: 'src/a.ts' });
+        expect(LinkUtil.resolve('/repo/', './src/../a.ts')).toEqual({ cwd: '/repo', path: 'a.ts' });
+        expect(LinkUtil.resolve('/repo', '/repo/src')).toEqual({ cwd: '/repo', path: 'src' });
+        expect(LinkUtil.resolve('/repo', '/repo')).toEqual({ cwd: '/repo', path: '' });
+        expect(LinkUtil.resolve('/repo', '../other/b.ts')).toEqual({ cwd: '/other', path: 'b.ts' });
+        expect(LinkUtil.resolve('/repo', '/etc/hosts')).toEqual({ cwd: '/etc', path: 'hosts' });
+        expect(LinkUtil.label({ type: 'path', path: 'a.ts', selection: { startLine: 3, startColumn: 2, endLine: 5 } })).toBe('a.ts:3:2-5');
+    });
+
+    it('trusts this machine, and the domains the user trusted', () => {
+        expect(LinkUtil.trusted('http://localhost:5173', [])).toBe(true);
+        expect(LinkUtil.trusted('http://127.0.0.1:8080', [])).toBe(true);
+        expect(LinkUtil.trusted('http://app.localhost', [])).toBe(true);
+        expect(LinkUtil.trusted('http://devbox:3000', [], 'devbox')).toBe(true);
+        expect(LinkUtil.trusted('https://github.com/a', [])).toBe(false);
+        expect(LinkUtil.trusted('https://github.com/a', ['github.com'])).toBe(true);
+        expect(LinkUtil.trusted('https://gist.github.com', ['github.com'])).toBe(false);
+        expect(LinkUtil.trusted('https://gist.github.com', ['*.github.com'])).toBe(true);
+        expect(LinkUtil.trusted('https://github.com', ['*.github.com'])).toBe(true);
+        expect(LinkUtil.trusted('https://evilgithub.com', ['*.github.com'])).toBe(false);
+        expect(LinkUtil.trusted('https://github.com.evil.dev', ['github.com'])).toBe(false);
+        expect(LinkUtil.trusted('http://x.dev:3000', ['x.dev:3000'])).toBe(true);
+        expect(LinkUtil.trusted('http://x.dev:4000', ['x.dev:3000'])).toBe(false);
+        expect(LinkUtil.trusted('https://any.dev', ['*'])).toBe(true);
+        // A look-alike host is compared as the browser reads it, in punycode.
+        expect(LinkUtil.trusted('https://gіthub.com', ['github.com'])).toBe(false);
+    });
+});

package/src/browser/util/link.ts

@@ -0,0 +1,237 @@
+import type { TextSelection } from '../extension/web-extension-api';
+
+/** What a link of a reply points to, as written: a page of the web, a mail, or a path on the machine of the conversation. */
+export type LinkTarget =
+    | { type: 'url'; url: string }
+    /** `mailto:`, which the browser hands to the mail program. */
+    | { type: 'mail'; url: string }
+    /** `path` decoded, without what names the selection; `directory` when it ends with `/`. */
+    | { type: 'path'; path: string; selection?: TextSelection; directory?: boolean };
+
+const WEB = /^https?:\/\//i;
+const SCHEME = /^[a-z][a-z\d+.-]*:/i;
+const WINDOWS_PATH = /^[a-z]:[\\/]/i;
+/** After `#`, as VS Code reads it: `L10`, `L10C5`, `L10-L20`, `L10C5-L12C3`, `10`, `10,5`, `10-20`. */
+const FRAGMENT = /^L?(\d+)(?:[C,](\d+))?(?:-L?(\d+)(?:[C,](\d+))?)?$/i;
+/** After a path, as compilers and grep print it: `:10`, `:10:5`, `:10-20`, `:10:5-12:3`. */
+const SUFFIX = /:(\d+)(?::(\d+))?(?:-(\d+)(?::(\d+))?)?$/;
+/** A URL in running text: ASCII only, so that the Chinese punctuation right after one is not part of it. */
+const BARE_URL = /^https?:\/\/[!#-&(-;=?-[\]_a-z~]+/i;
+/**
+ * Names of files that a code span alone (`package.json`) may name; with a `/` or a line, any extension does.
+ * Not `env` or `c`: `process.env` and `a.b.c` are code.
+ */
+const COMMON_EXTENSIONS = new Set(
+    'ts tsx mts cts js jsx mjs cjs json jsonc md mdx yml yaml toml ini lock py rb go rs java kt kts swift cc cpp hpp cs php sh bash zsh css scss less html htm vue svelte sql xml gradle txt csv svg'.split(
+        ' ',
+    ),
+);
+const CODE_PATH = /^(?:\.{1,2}\/|\/)?(?:[\w@+-][\w@.+-]*\/)*[\w@+-][\w@.+-]*\/?$/;
+const LOOPBACK = /^(localhost|.+\.localhost|127(\.\d{1,3}){3}|\[::1\]|0\.0\.0\.0)$/;
+
+/**
+ * Links of replies, read as VS Code reads them in its chat: http(s) URLs, and paths of files and
+ * directories with the lines they point to. Every other scheme (`javascript:`, `data:`, `command:`…)
+ * is no link at all. Pure functions: what a click does is TaLinks's.
+ */
+export namespace LinkUtil {
+    /** The target of `[text](target)` or of a URL in the text; undefined for what is no link. */
+    export function parse(target: string): LinkTarget | undefined {
+        if (WEB.test(target)) {
+            try {
+                return { type: 'url', url: new URL(target).href };
+            } catch {
+                return undefined;
+            }
+        }
+        if (/^mailto:[^\s]+@/i.test(target)) {
+            return { type: 'mail', url: target };
+        }
+        let rest = target;
+        if (/^file:/i.test(rest)) {
+            const url = /^file:\/\/(?:localhost)?(\/.*)$/i.exec(rest);
+            if (!url) {
+                return undefined;
+            }
+            rest = url[1];
+        } else if (rest.startsWith('//') || (SCHEME.test(rest.replace(SUFFIX, '')) && !WINDOWS_PATH.test(rest))) {
+            return undefined;
+        }
+        const hash = rest.indexOf('#');
+        const fragment = hash < 0 ? '' : rest.slice(hash + 1);
+        let path = (hash < 0 ? rest : rest.slice(0, hash)).split('?')[0];
+        let selection = fragment ? fromFragment(fragment) : undefined;
+        if (!fragment) {
+            const suffix = SUFFIX.exec(path);
+            if (suffix) {
+                selection = fromNumbers(suffix);
+                path = path.slice(0, suffix.index);
+            }
+        }
+        try {
+            path = decodeURI(path);
+        } catch {
+            // Kept as written.
+        }
+        if (!path) {
+            return undefined;
+        }
+        const directory = path.length > 1 && path.endsWith('/');
+        return { type: 'path', path: directory ? path.replace(/\/+$/, '') : path, ...(selection && { selection }), ...(directory && { directory }) };
+    }
+
+    /**
+     * A code span that names a file or a directory, as models write them: `src/app.ts:12`, `package.json`,
+     * `docs/`. Not `console.log`, `text/html` or `@celljs/core`: a name needs an extension, and alone one
+     * that files have, or a `/` at its end.
+     */
+    export function codeReference(text: string): LinkTarget | undefined {
+        if (/\s/.test(text) || text.includes('://') || text.startsWith('@')) {
+            return undefined;
+        }
+        const suffix = SUFFIX.exec(text);
+        const path = suffix ? text.slice(0, suffix.index) : text;
+        if (!CODE_PATH.test(path) || path === '/') {
+            return undefined;
+        }
+        if (!path.endsWith('/')) {
+            const extension = /[^/.]\.([a-z][a-z\d]{0,9})$/i.exec(path)?.[1].toLowerCase();
+            if (!extension || !(suffix || path.includes('/') || COMMON_EXTENSIONS.has(extension))) {
+                return undefined;
+            }
+            // Node.js, Vue.js: names of projects, not files.
+            if (!suffix && !path.includes('/') && extension === 'js' && /^[A-Z]/.test(path)) {
+                return undefined;
+            }
+        }
+        return parse(text);
+    }
+
+    /** A URL at the start of `text` (text runs on after it), without the punctuation that ends a sentence. */
+    export function bareUrl(text: string): string | undefined {
+        let url = BARE_URL.exec(text)?.[0];
+        if (!url) {
+            return undefined;
+        }
+        url = url.replace(/[.,;:!?'"*_~]+$/, '');
+        // A ) closes the text's ( rather than the URL's, unless the URL opened one.
+        while (url.endsWith(')') && count(url, '(') < count(url, ')')) {
+            url = url.slice(0, -1).replace(/[.,;:!?]+$/, '');
+        }
+        return /^https?:\/\/[^/?#]/i.test(url) ? url : undefined;
+    }
+
+    /** `path` against the directory `cwd`: the directory to read it in, and the path inside it ('' for the directory itself). */
+    export function resolve(cwd: string, path: string): { cwd: string; path: string } {
+        if (cwd.includes('\\') || path.includes('\\')) {
+            // A Windows server resolves its own paths.
+            return { cwd, path };
+        }
+        const absolute = normalize(path.startsWith('/') ? path : `${cwd}/${path}`);
+        const base = normalize(cwd);
+        if (absolute === base) {
+            return { cwd: base, path: '' };
+        }
+        if (base === '/' || absolute.startsWith(`${base}/`)) {
+            return { cwd: base, path: absolute.slice(base === '/' ? 1 : base.length + 1) };
+        }
+        // Outside the directory of the conversation: read in its own directory.
+        const slash = absolute.lastIndexOf('/');
+        return { cwd: absolute.slice(0, slash) || '/', path: absolute.slice(slash + 1) };
+    }
+
+    /** `a/./b/../c/` as `a/c`; an absolute path stays absolute. */
+    export function normalize(path: string): string {
+        const parts: string[] = [];
+        for (const part of path.split('/')) {
+            if (part === '..') {
+                parts.pop();
+            } else if (part && part !== '.') {
+                parts.push(part);
+            }
+        }
+        const joined = parts.join('/');
+        return path.startsWith('/') ? `/${joined}` : joined;
+    }
+
+    export function join(dir: string, path: string): string {
+        return path ? normalize(`${dir}/${path}`) : dir;
+    }
+
+    export function dirname(path: string): string {
+        const slash = path.lastIndexOf('/');
+        return slash < 0 ? '' : path.slice(0, slash);
+    }
+
+    export function basename(path: string): string {
+        return path.slice(path.lastIndexOf('/') + 1);
+    }
+
+    /** The path with its lines, as the user reads it: `src/a.ts:10:5`. */
+    export function label(target: LinkTarget): string {
+        if (target.type !== 'path') {
+            return target.url;
+        }
+        const { selection } = target;
+        if (!selection) {
+            return target.directory ? `${target.path}/` : target.path;
+        }
+        const start = selection.startColumn ? `${selection.startLine}:${selection.startColumn}` : `${selection.startLine}`;
+        const end = selection.endLine ? `-${selection.endLine}${selection.endColumn ? `:${selection.endColumn}` : ''}` : '';
+        return `${target.path}:${start}${end}`;
+    }
+
+    /**
+     * Whether a page of `url` opens without asking, as VS Code's trusted domains: this machine (and the
+     * host of ta serve, `ownHost`) always; else a domain the user trusted: `github.com`, `*.github.com`
+     * (the domain and those under it), `localhost:3000` (that port only), or `*` for all.
+     */
+    export function trusted(url: string, domains: readonly string[], ownHost?: string): boolean {
+        let parsed: URL;
+        try {
+            parsed = new URL(url);
+        } catch {
+            return false;
+        }
+        const host = parsed.hostname.toLowerCase();
+        if (LOOPBACK.test(host) || (ownHost && host === ownHost.toLowerCase())) {
+            return true;
+        }
+        return domains.some(domain => {
+            const pattern = domain
+                .trim()
+                .toLowerCase()
+                .replace(/^[a-z]+:\/\//, '')
+                .replace(/\/.*$/, '');
+            if (pattern === '*') {
+                return true;
+            }
+            if (pattern.startsWith('*.')) {
+                return host === pattern.slice(2) || host.endsWith(pattern.slice(1));
+            }
+            return pattern.includes(':') ? parsed.host.toLowerCase() === pattern : host === pattern;
+        });
+    }
+
+    function fromFragment(fragment: string): TextSelection | undefined {
+        const found = FRAGMENT.exec(fragment);
+        return found ? fromNumbers(found) : undefined;
+    }
+
+    function fromNumbers(found: RegExpExecArray): TextSelection | undefined {
+        const [startLine, startColumn, endLine, endColumn] = found.slice(1, 5).map(value => (value ? Number(value) : undefined));
+        if (!startLine) {
+            return undefined;
+        }
+        return {
+            startLine,
+            ...(startColumn && { startColumn }),
+            ...(endLine && endLine >= startLine && { endLine }),
+            ...(endLine && endLine >= startLine && endColumn && { endColumn }),
+        };
+    }
+
+    function count(text: string, char: string): number {
+        return text.split(char).length - 1;
+    }
+}