@adecore/editor-react 0.22.0 → 0.23.0

package/src/snippet-transform-client.ts

@@ -0,0 +1,84 @@
+import { createWorkerRequestClient, WorkerRequestError, type WorkerRequestPort } from '@adecore/editor/worker-client';
+import { validateSnippetTransformJobs } from './snippet-transform-format.ts';
+import { MAX_TRANSFORM_CHARACTERS, type SnippetTransformInput, type SnippetTransformOutput, type SnippetTransformJob } from './snippet-transform-protocol.ts';
+export type SnippetTransformErrorKind = 'syntax' | 'range' | 'error' | 'timeout' | 'superseded' | 'unavailable' | 'disposed';
+export class SnippetTransformError extends Error {
+    readonly kind: SnippetTransformErrorKind;
+    constructor(kind: SnippetTransformErrorKind, message: string) {
+        super(message);
+        this.kind = kind;
+        this.name = 'SnippetTransformError';
+    }
+}
+export interface SnippetTransformClientOptions {
+    readonly workerFactory: () => WorkerRequestPort;
+    readonly deadline?: number;
+    readonly schedule?: (callback: () => void, delay: number) => () => void;
+}
+export interface SnippetTransformClient {
+    transform(jobs: readonly SnippetTransformJob[]): Promise<readonly string[]>;
+    cancel(): void;
+    release(): void;
+    dispose(): void;
+}
+export function createSnippetTransformClient(options: SnippetTransformClientOptions): SnippetTransformClient {
+    const transport = createWorkerRequestClient<SnippetTransformInput, Exclude<SnippetTransformOutput, { type: 'ready' }>>({
+        ...options,
+        failure: (reply) =>
+            reply.type === 'error' ? { error: new SnippetTransformError(reply.kind, reply.message), restart: reply.kind === 'error' } : undefined
+    });
+    let disposed = false;
+    const failure = (error: unknown): SnippetTransformError =>
+        error instanceof SnippetTransformError
+            ? error
+            : error instanceof WorkerRequestError
+              ? new SnippetTransformError(error.kind, error.message)
+              : new SnippetTransformError(
+                    error instanceof SyntaxError ? 'syntax' : error instanceof RangeError ? 'range' : 'error',
+                    error instanceof Error ? error.message : String(error)
+                );
+    return {
+        transform(jobs) {
+            if (disposed) {
+                return Promise.reject(new SnippetTransformError('disposed', 'The snippet transform client was disposed.'));
+            }
+            if (Array.isArray(jobs) && jobs.length === 0) {
+                return Promise.resolve([]);
+            }
+            let copied: SnippetTransformJob[];
+            try {
+                validateSnippetTransformJobs(jobs);
+                copied = jobs.map((job) => ({ ...job, format: job.format.map((node) => ({ ...node })) }));
+            } catch (error) {
+                return Promise.reject(failure(error));
+            }
+            return transport
+                .request((id) => ({ type: 'transform', id, jobs: copied }))
+                .then((reply) => {
+                    if (
+                        reply.type !== 'transformed' ||
+                        !Array.isArray(reply.values) ||
+                        reply.values.length !== copied.length ||
+                        reply.values.some((value) => typeof value !== 'string') ||
+                        reply.values.reduce((sum, value) => sum + value.length, 0) > MAX_TRANSFORM_CHARACTERS
+                    ) {
+                        throw new SnippetTransformError('error', 'Invalid snippet transform response.');
+                    }
+                    return reply.values;
+                })
+                .catch((error) => {
+                    throw failure(error);
+                });
+        },
+        cancel() {
+            transport.cancel();
+        },
+        release() {
+            transport.release();
+        },
+        dispose() {
+            disposed = true;
+            transport.dispose();
+        }
+    };
+}

package/src/snippet-transform-format.ts

@@ -0,0 +1,325 @@
+import {
+    MAX_TRANSFORM_FORMAT,
+    MAX_TRANSFORM_NODES,
+    MAX_TRANSFORM_PATTERN,
+    MAX_TRANSFORM_JOBS,
+    MAX_TRANSFORM_VALUE,
+    MAX_TRANSFORM_CHARACTERS,
+    MAX_TRANSFORM_MATCHES,
+    MAX_TRANSFORM_WORK,
+    type SnippetTransformCase,
+    type SnippetTransformFormatNode,
+    type SnippetTransformJob
+} from './snippet-transform-protocol.ts';
+const CASES: ReadonlySet<string> = new Set(['upcase', 'downcase', 'capitalize', 'camelcase', 'pascalcase']);
+function readFormat(source: string, start: number, stopAtSlash: boolean): { nodes: readonly SnippetTransformFormatNode[]; end: number } {
+    const nodes: SnippetTransformFormatNode[] = [];
+    let at = start,
+        text = '';
+    const bound = (): void => {
+        if (at - start > MAX_TRANSFORM_FORMAT) {
+            throw new RangeError('The transform format is too long.');
+        }
+    };
+    const push = (node: SnippetTransformFormatNode): void => {
+        if (nodes.length >= MAX_TRANSFORM_NODES) {
+            throw new RangeError('The transform format has too many nodes.');
+        }
+        nodes.push(node);
+    };
+    const flush = (): void => {
+        if (text !== '') {
+            push({ kind: 'text', text });
+            text = '';
+        }
+    };
+    const string = (colon = false): string => {
+        let value = '';
+        while (at < source.length && source[at] !== '}' && !(colon && source[at] === ':')) {
+            if (source[at] === '\\') {
+                if (!['$', '}', '\\'].includes(source[at + 1] ?? '')) {
+                    throw new SyntaxError('Invalid conditional transform escape.');
+                }
+                at++;
+            }
+            value += source[at++]!;
+            bound();
+        }
+        return value;
+    };
+    while (at < source.length && !(stopAtSlash && source[at] === '/')) {
+        bound();
+        if (source[at] === '\\' && (source[at + 1] === '\\' || source[at + 1] === '/')) {
+            at++;
+            text += source[at++]!;
+            continue;
+        }
+        if (source[at] !== '$') {
+            text += source[at++]!;
+            continue;
+        }
+        at++;
+        const brace = source[at] === '{';
+        if (brace) {
+            at++;
+        }
+        const start = at;
+        while (at < source.length && source.charCodeAt(at) >= 48 && source.charCodeAt(at) <= 57) {
+            at++;
+        }
+        if (at === start) {
+            if (brace) {
+                throw new SyntaxError('A transform format needs a capture index.');
+            }
+            text += '$';
+            continue;
+        }
+        const index = Number(source.slice(start, at));
+        if (index > 99) {
+            throw new RangeError('Transform captures are limited to 99.');
+        }
+        flush();
+        let node: SnippetTransformFormatNode = { kind: 'capture', index };
+        if (brace) {
+            if (source[at] === ':') {
+                at++;
+                const operator = source[at];
+                if (operator === '/') {
+                    at++;
+                    const operation = string();
+                    if (!CASES.has(operation)) {
+                        throw new SyntaxError('Unknown transform case operation.');
+                    }
+                    node = { kind: 'capture', index, case: operation as SnippetTransformCase };
+                } else if (operator === '+') {
+                    at++;
+                    node = { kind: 'conditional', index, if: string() };
+                } else if (operator === '?') {
+                    at++;
+                    const when = string(true);
+                    if (source[at++] !== ':') {
+                        throw new SyntaxError('A conditional transform needs both branches.');
+                    }
+                    node = { kind: 'conditional', index, if: when, else: string() };
+                } else {
+                    if (operator === '-') {
+                        at++;
+                    }
+                    node = { kind: 'conditional', index, else: string() };
+                }
+            }
+            if (source[at++] !== '}') {
+                throw new SyntaxError('An unclosed transform capture cannot be applied.');
+            }
+        }
+        push(node);
+    }
+    flush();
+    bound();
+    if (stopAtSlash && source[at] !== '/') {
+        throw new SyntaxError('Unclosed snippet transform format.');
+    }
+    return { nodes, end: at };
+}
+export function compileSnippetTransformFormat(source: string): readonly SnippetTransformFormatNode[] {
+    return readFormat(source, 0, false).nodes;
+}
+export function scanSnippetTransform(
+    source: string,
+    at: number
+): { pattern: string; flags: string; format: readonly SnippetTransformFormatNode[]; end: number } {
+    if (source[at++] !== '/') {
+        throw new SyntaxError('A snippet transform needs an opening slash.');
+    }
+    let pattern = '';
+    while (at < source.length && source[at] !== '/') {
+        const character = source[at++]!;
+        if (character === '\\' && source[at] === '/') {
+            pattern += source[at++]!;
+        } else {
+            pattern += character;
+        }
+        if (pattern.length > MAX_TRANSFORM_PATTERN) {
+            throw new RangeError('The snippet transform pattern is too long.');
+        }
+    }
+    if (source[at++] !== '/') {
+        throw new SyntaxError('Unclosed snippet transform pattern.');
+    }
+    const parsed = readFormat(source, at, true);
+    at = parsed.end + 1;
+    let flags = '';
+    while (at < source.length && source[at] !== '}') {
+        const flag = source[at++]!;
+        if (!'gimsu'.includes(flag) || flags.includes(flag)) {
+            throw new SyntaxError('Invalid snippet transform flags.');
+        }
+        flags += flag;
+    }
+    if (source[at++] !== '}') {
+        throw new SyntaxError('Unclosed snippet transform flags.');
+    }
+    return { pattern, flags, format: parsed.nodes, end: at };
+}
+function capitalize(value: string): string {
+    const first = value.slice(0, (value.codePointAt(0) ?? 0) > 0xffff ? 2 : 1);
+    return first.toUpperCase() + value.slice(first.length);
+}
+function changeCase(value: string, operation?: SnippetTransformCase): string {
+    if (operation === 'upcase') {
+        return value.toUpperCase();
+    }
+    if (operation === 'downcase') {
+        return value.toLowerCase();
+    }
+    if (operation === 'capitalize') {
+        return capitalize(value);
+    }
+    if (operation === 'camelcase' || operation === 'pascalcase') {
+        const words = value.match(/[\p{L}0-9]+/gu);
+        if (words === null) {
+            return value;
+        }
+        return words
+            .map((word, index) => (operation === 'camelcase' && index === 0 ? word.slice(0, 1).toLowerCase() + word.slice(1) : capitalize(word)))
+            .join('');
+    }
+    return value;
+}
+export function validateSnippetTransformJobs(jobs: readonly SnippetTransformJob[]): void {
+    if (!Array.isArray(jobs) || jobs.length > MAX_TRANSFORM_JOBS) {
+        throw new RangeError('Too many snippet transform jobs.');
+    }
+    let characters = 0;
+    const patterns = new Set<string>();
+    for (const job of jobs) {
+        if (
+            typeof job.value !== 'string' ||
+            job.value.length > MAX_TRANSFORM_VALUE ||
+            typeof job.pattern !== 'string' ||
+            job.pattern.length > MAX_TRANSFORM_PATTERN
+        ) {
+            throw new RangeError('A snippet transform value or pattern is too large.');
+        }
+        characters += job.value.length + job.pattern.length;
+        if (characters > MAX_TRANSFORM_CHARACTERS || !Array.isArray(job.format) || job.format.length > MAX_TRANSFORM_NODES) {
+            throw new RangeError('The snippet transform batch is too large.');
+        }
+        if (
+            typeof job.flags !== 'string' ||
+            Array.from(job.flags as string).some((flag) => !'gimsu'.includes(flag)) ||
+            new Set(job.flags).size !== job.flags.length
+        ) {
+            throw new SyntaxError('Snippet transforms support the flags g, i, m, s and u once each.');
+        }
+        let formatLength = 0;
+        for (const node of job.format) {
+            if (node.kind === 'text') {
+                if (typeof node.text !== 'string') {
+                    throw new SyntaxError('Invalid transform text.');
+                }
+                formatLength += node.text.length;
+            } else if (node.kind === 'capture' || node.kind === 'conditional') {
+                if (!Number.isInteger(node.index) || node.index < 0 || node.index > 99) {
+                    throw new RangeError('Invalid transform capture index.');
+                }
+                if (node.kind === 'capture' && node.case !== undefined && !CASES.has(node.case)) {
+                    throw new SyntaxError('Invalid transform case operation.');
+                }
+                if (node.kind === 'conditional') {
+                    if ((node.if !== undefined && typeof node.if !== 'string') || (node.else !== undefined && typeof node.else !== 'string')) {
+                        throw new SyntaxError('Invalid transform branches.');
+                    }
+                    formatLength += (node.if?.length ?? 0) + (node.else?.length ?? 0);
+                }
+            } else {
+                throw new SyntaxError('Invalid transform format node.');
+            }
+        }
+        if (formatLength > MAX_TRANSFORM_FORMAT) {
+            throw new RangeError('The transform format is too long.');
+        }
+        characters += formatLength;
+        if (characters > MAX_TRANSFORM_CHARACTERS) {
+            throw new RangeError('The snippet transform batch is too large.');
+        }
+        const key = job.flags + '\0' + job.pattern;
+        if (!patterns.has(key)) {
+            // Compilation validates syntax; only the worker executes patterns supplied by a server.
+            new RegExp(job.pattern, job.flags);
+            patterns.add(key);
+        }
+    }
+}
+export interface SnippetTransformBudget {
+    remaining: number;
+    matches: number;
+}
+export function createSnippetTransformBudget(): SnippetTransformBudget {
+    return { remaining: MAX_TRANSFORM_WORK, matches: 0 };
+}
+function spend(budget: SnippetTransformBudget, amount: number): void {
+    budget.remaining -= amount;
+    if (budget.remaining < 0) {
+        throw new RangeError('The snippet transform work budget was exceeded.');
+    }
+}
+export function applySnippetTransform(
+    job: SnippetTransformJob,
+    maximum = MAX_TRANSFORM_CHARACTERS,
+    expression = new RegExp(job.pattern, job.flags),
+    budget = createSnippetTransformBudget()
+): string {
+    expression.lastIndex = 0;
+    spend(budget, job.value.length);
+    const pieces: string[] = [];
+    let at = 0,
+        length = 0,
+        matches = 0;
+    const append = (text: string): void => {
+        if (text === '') {
+            return;
+        }
+        length += text.length;
+        if (length > maximum) {
+            throw new RangeError('The snippet transform output is too large.');
+        }
+        pieces.push(text);
+    };
+    const format = (captures: readonly (string | undefined)[]): void => {
+        for (const node of job.format) {
+            spend(budget, 1);
+            if (node.kind === 'text') {
+                append(node.text);
+            } else {
+                const capture = captures[node.index] ?? '';
+                if (node.kind === 'capture' && node.case !== undefined) {
+                    spend(budget, capture.length);
+                }
+                append(node.kind === 'capture' ? changeCase(capture, node.case) : capture !== '' ? (node.if ?? capture) : (node.else ?? ''));
+            }
+        }
+    };
+    for (let match = expression.exec(job.value); match !== null; match = expression.exec(job.value)) {
+        if (++budget.matches > MAX_TRANSFORM_MATCHES) {
+            throw new RangeError('The snippet transform batch has too many matches.');
+        }
+        matches++;
+        spend(budget, 1);
+        append(job.value.slice(at, match.index));
+        format(match);
+        at = match.index + match[0].length;
+        if (!expression.global) {
+            break;
+        }
+        if (match[0].length === 0) {
+            expression.lastIndex += expression.unicode && (job.value.codePointAt(expression.lastIndex) ?? 0) > 0xffff ? 2 : 1;
+        }
+    }
+    if (matches === 0 && job.format.some((node) => node.kind === 'conditional' && Boolean(node.else))) {
+        format([]);
+    } else {
+        append(job.value.slice(at));
+    }
+    return pieces.join('');
+}

package/src/snippet-transform-protocol.ts

@@ -0,0 +1,24 @@
+export const MAX_TRANSFORM_JOBS = 1000;
+export const MAX_TRANSFORM_VALUE = 100_000;
+export const MAX_TRANSFORM_CHARACTERS = 2_000_000;
+export const MAX_TRANSFORM_MATCHES = 10_000;
+export const MAX_TRANSFORM_WORK = 1_000_000;
+export const MAX_TRANSFORM_PATTERN = 1024;
+export const MAX_TRANSFORM_FORMAT = 10_000;
+export const MAX_TRANSFORM_NODES = 1000;
+export type SnippetTransformCase = 'upcase' | 'downcase' | 'capitalize' | 'camelcase' | 'pascalcase';
+export type SnippetTransformFormatNode =
+    | { readonly kind: 'text'; readonly text: string }
+    | { readonly kind: 'capture'; readonly index: number; readonly case?: SnippetTransformCase }
+    | { readonly kind: 'conditional'; readonly index: number; readonly if?: string; readonly else?: string };
+export interface SnippetTransformJob {
+    readonly value: string;
+    readonly pattern: string;
+    readonly flags: string;
+    readonly format: readonly SnippetTransformFormatNode[];
+}
+export type SnippetTransformInput = { readonly type: 'transform'; readonly id: number; readonly jobs: readonly SnippetTransformJob[] };
+export type SnippetTransformOutput =
+    | { readonly type: 'ready' }
+    | { readonly type: 'transformed'; readonly id: number; readonly values: readonly string[] }
+    | { readonly type: 'error'; readonly id: number; readonly kind: 'syntax' | 'range' | 'error'; readonly message: string };

package/src/snippet-transform-queue.ts

@@ -0,0 +1,199 @@
+import type { WorkerRequestPort } from '@adecore/editor/worker-client';
+import { createSnippetTransformClient, SnippetTransformError, type SnippetTransformClient } from './snippet-transform-client.ts';
+import { validateSnippetTransformJobs } from './snippet-transform-format.ts';
+import { MAX_TRANSFORM_WORK, type SnippetTransformJob } from './snippet-transform-protocol.ts';
+import type { ProjectLanguage } from './project-language.ts';
+import { realTimers, type Timers } from './timers.ts';
+
+interface RequestOptions {
+    readonly kind?: 'accept' | 'exit';
+    readonly current?: () => boolean;
+}
+export interface SnippetTransformLease {
+    request(jobs: readonly SnippetTransformJob[], options?: RequestOptions): Promise<readonly string[]>;
+    dispose(): void;
+}
+interface Job {
+    readonly owner: symbol;
+    readonly kind: 'accept' | 'exit';
+    readonly jobs: readonly SnippetTransformJob[];
+    readonly current: () => boolean;
+    readonly resolve: (values: readonly string[]) => void;
+    readonly reject: (error: unknown) => void;
+}
+export class SnippetTransformQueueError extends Error {}
+
+const IDLE_RELEASE_MS = 1000;
+const MAX_PENDING = 16;
+
+export class SnippetTransforms {
+    private readonly client: SnippetTransformClient;
+    private readonly timers: Timers;
+    private readonly owners = new Set<symbol>();
+    private pending: Job[] = [];
+    private active: Job | null = null;
+    private idle: unknown;
+    private disposed = false;
+    constructor(factory: () => WorkerRequestPort, timers: Timers = realTimers) {
+        this.timers = timers;
+        this.client = createSnippetTransformClient({
+            workerFactory: factory,
+            schedule: (callback, delay) => {
+                const timer = timers.set(callback, delay);
+                return () => timers.clear(timer);
+            }
+        });
+    }
+    acquire(): SnippetTransformLease {
+        const owner = Symbol('snippet');
+        this.owners.add(owner);
+        return {
+            request: (jobs, options = {}) => this.request(owner, jobs, options),
+            dispose: () => this.releaseOwner(owner)
+        };
+    }
+    private request(owner: symbol, jobs: readonly SnippetTransformJob[], options: RequestOptions): Promise<readonly string[]> {
+        if (this.disposed || !this.owners.has(owner)) {
+            return Promise.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
+        }
+        let copied: SnippetTransformJob[];
+        try {
+            validateSnippetTransformJobs(jobs);
+            if (jobs.reduce((sum, job) => sum + job.value.length, 0) > MAX_TRANSFORM_WORK) {
+                throw new RangeError('The snippet transform inputs exceed the work budget.');
+            }
+            copied = jobs.map((job) => ({ ...job, format: job.format.map((node) => ({ ...node })) }));
+        } catch (error) {
+            return Promise.reject(
+                new SnippetTransformError(error instanceof RangeError ? 'range' : 'syntax', error instanceof Error ? error.message : String(error))
+            );
+        }
+        if (copied.length === 0) {
+            return Promise.resolve([]);
+        }
+        this.pending = this.pending.filter((job) => {
+            if (job.current()) {
+                return true;
+            }
+            job.reject(new SnippetTransformError('superseded', 'The queued snippet changed.'));
+            return false;
+        });
+        const kind = options.kind ?? 'accept';
+        if (kind === 'accept') {
+            this.pending = this.pending.filter((job) => {
+                if (job.owner !== owner || job.kind !== 'accept') {
+                    return true;
+                }
+                job.reject(new SnippetTransformError('superseded', 'A newer snippet accept replaced the queued one.'));
+                return false;
+            });
+        }
+        if (this.pending.length >= MAX_PENDING) {
+            return Promise.reject(new SnippetTransformQueueError('Too many queued snippet transforms.'));
+        }
+        this.timers.clear(this.idle);
+        return new Promise((resolve, reject) => {
+            this.pending.push({ owner, kind, jobs: copied, current: () => this.owners.has(owner) && (options.current?.() ?? true), resolve, reject });
+            queueMicrotask(() => this.pump());
+        });
+    }
+    private pump(): void {
+        if (this.disposed || this.active !== null) {
+            return;
+        }
+        const job = this.pending.shift();
+        if (job === undefined) {
+            this.timers.clear(this.idle);
+            this.idle = this.timers.set(() => this.client.release(), IDLE_RELEASE_MS);
+            return;
+        }
+        if (!job.current()) {
+            job.reject(new SnippetTransformError('superseded', 'The queued snippet changed.'));
+            this.pump();
+            return;
+        }
+        this.active = job;
+        void this.client
+            .transform(job.jobs)
+            .then((values) => {
+                if (!job.current()) {
+                    throw new SnippetTransformError('superseded', 'The snippet changed while transforming.');
+                }
+                job.resolve(values);
+            })
+            .catch((error) => job.reject(error))
+            .finally(() => {
+                this.active = null;
+                this.pump();
+            });
+    }
+    private releaseOwner(owner: symbol): void {
+        if (!this.owners.delete(owner)) {
+            return;
+        }
+        this.pending = this.pending.filter((job) => {
+            if (job.owner !== owner) {
+                return true;
+            }
+            job.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
+            return false;
+        });
+        if (this.active?.owner === owner) {
+            this.active.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
+            this.client.cancel();
+        }
+        if (this.owners.size === 0) {
+            this.dispose();
+        }
+    }
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.timers.clear(this.idle);
+        this.owners.clear();
+        const error = new SnippetTransformError('disposed', 'The project snippet transforms were disposed.');
+        this.active?.reject(error);
+        this.pending.forEach((job) => job.reject(error));
+        this.pending = [];
+        this.client.dispose();
+    }
+}
+interface Entry {
+    readonly queue: SnippetTransforms;
+    references: number;
+}
+const projects = new WeakMap<ProjectLanguage, Entry>();
+export function acquireSnippetTransforms(project: ProjectLanguage, timers: Timers): SnippetTransformLease | null {
+    const factory = project.host.snippetTransformWorker;
+    if (factory === undefined) {
+        return null;
+    }
+    let entry = projects.get(project);
+    if (entry === undefined) {
+        entry = { queue: new SnippetTransforms(factory, timers), references: 0 };
+        projects.set(project, entry);
+    }
+    const held = entry,
+        lease = held.queue.acquire();
+    held.references++;
+    let disposed = false;
+    return {
+        request: (jobs, options) => lease.request(jobs, options),
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            lease.dispose();
+            if (--held.references === 0 && projects.get(project) === held) {
+                projects.delete(project);
+            }
+        }
+    };
+}
+export function disposeSnippetTransforms(project: ProjectLanguage): void {
+    projects.get(project)?.queue.dispose();
+    projects.delete(project);
+}

package/src/snippet-transform-worker.ts

@@ -0,0 +1,58 @@
+import { applySnippetTransform, createSnippetTransformBudget, validateSnippetTransformJobs } from './snippet-transform-format.ts';
+import { MAX_TRANSFORM_CHARACTERS, type SnippetTransformInput, type SnippetTransformOutput } from './snippet-transform-protocol.ts';
+export {
+    createSnippetTransformClient,
+    SnippetTransformError,
+    type SnippetTransformClient,
+    type SnippetTransformClientOptions,
+    type SnippetTransformErrorKind
+} from './snippet-transform-client.ts';
+export { compileSnippetTransformFormat } from './snippet-transform-format.ts';
+export type {
+    SnippetTransformJob,
+    SnippetTransformInput,
+    SnippetTransformOutput,
+    SnippetTransformCase,
+    SnippetTransformFormatNode
+} from './snippet-transform-protocol.ts';
+export interface SnippetTransformWorkerEndpoint {
+    addEventListener(type: 'message', listener: (event: MessageEvent<SnippetTransformInput>) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent<SnippetTransformInput>) => void): void;
+    postMessage(message: SnippetTransformOutput): void;
+}
+export function serveSnippetTransforms(endpoint: SnippetTransformWorkerEndpoint): () => void {
+    const receive = ({ data: request }: MessageEvent<SnippetTransformInput>): void => {
+        const id = request !== null && typeof request === 'object' && Number.isSafeInteger(request.id) && request.id > 0 ? request.id : 0;
+        try {
+            if (id === 0 || request.type !== 'transform') {
+                throw new RangeError('Invalid snippet transform request.');
+            }
+            validateSnippetTransformJobs(request.jobs);
+            let remaining = MAX_TRANSFORM_CHARACTERS;
+            const budget = createSnippetTransformBudget();
+            const patterns = new Map<string, RegExp>();
+            const values = request.jobs.map((job) => {
+                const key = job.flags + '\0' + job.pattern;
+                let expression = patterns.get(key);
+                if (expression === undefined) {
+                    expression = new RegExp(job.pattern, job.flags);
+                    patterns.set(key, expression);
+                }
+                const value = applySnippetTransform(job, remaining, expression, budget);
+                remaining -= value.length;
+                return value;
+            });
+            endpoint.postMessage({ type: 'transformed', id: request.id, values });
+        } catch (error) {
+            endpoint.postMessage({
+                type: 'error',
+                id,
+                kind: error instanceof SyntaxError ? 'syntax' : error instanceof RangeError ? 'range' : 'error',
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    };
+    endpoint.addEventListener('message', receive);
+    endpoint.postMessage({ type: 'ready' });
+    return () => endpoint.removeEventListener('message', receive);
+}