@singapore-editor/lsp-plugin 0.1.1

package/dist/lspConnectionPool.js

@@ -0,0 +1,255 @@
+import { LspConnection } from "./lspConnection.js";
+//#region src/lspConnectionPool.ts
+/**
+* How long a connection with no borrowers is kept. A file switch drops the lease count to zero for a
+* tick or two on its way from one view to the next; the cost of holding on is one idle socket, the
+* cost of letting go early is another handshake against a server that may still be indexing.
+*/
+var DEFAULT_IDLE_GRACE_MS = 3e4;
+/**
+* One connection per key, outliving the views that borrow it. A view contribution is rebuilt on
+* every file switch, and a connection it owns dies with it — thirteen handshakes in twenty-two
+* seconds, measured. The key is opaque: how a server session is named is the host's vocabulary.
+*/
+var LspConnectionPool = class {
+	#entries = /* @__PURE__ */ new Map();
+	#idleGraceMs;
+	#onEvent;
+	constructor(options = {}) {
+		this.#idleGraceMs = options.idleGraceMs ?? DEFAULT_IDLE_GRACE_MS;
+		this.#onEvent = options.onEvent;
+	}
+	/** A provider bound to one key, in the shape the plugin takes. */
+	provider(key) {
+		return { acquire: (options, callbacks) => this.acquire(key, options, callbacks) };
+	}
+	acquire(key, options, callbacks) {
+		const existing = this.#entries.get(key);
+		if (existing) this.#assertCompatible(existing, options);
+		const entry = existing ?? this.#create(key, options);
+		if (entry.idleTimer !== null) {
+			clearTimeout(entry.idleTimer);
+			entry.idleTimer = null;
+		}
+		const lease = {
+			callbacks,
+			notificationHandlers: options.notificationHandlers ?? {},
+			serverRequestHandlers: options.serverRequestHandlers ?? {}
+		};
+		this.#reportUndispatchable(entry, lease);
+		entry.leases.add(lease);
+		this.#emit(entry, existing ? "reused" : "created");
+		this.#replayTo(entry, lease);
+		return {
+			connection: entry.connection,
+			release: () => this.#release(entry, lease)
+		};
+	}
+	/** Closes every connection. For teardown and for tests, not for routine use. */
+	dispose() {
+		for (const entry of this.#entries.values()) {
+			if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
+			entry.connection.dispose();
+		}
+		this.#entries.clear();
+	}
+	#create(key, options) {
+		const notificationMethods = new Set(Object.keys(options.notificationHandlers ?? {}));
+		const entry = {
+			connected: false,
+			connection: null,
+			createdAt: now(),
+			idleTimer: null,
+			initializationContract: initializationContract(options),
+			key,
+			leases: /* @__PURE__ */ new Set(),
+			notificationMethods,
+			readyAt: null,
+			status: "idle"
+		};
+		entry.connection = new LspConnection({
+			...options,
+			notificationHandlers: this.#dispatchers(entry, notificationMethods),
+			serverRequestHandlers: requestDispatchers(entry, options.serverRequestHandlers ?? {})
+		}, this.#fanOut(entry));
+		this.#entries.set(key, entry);
+		entry.connection.connect();
+		return entry;
+	}
+	#assertCompatible(entry, options) {
+		const incoming = initializationContract(options);
+		if (structurallyEqual(entry.initializationContract, incoming)) return;
+		throw new Error(`LSP connection pool key "${entry.key}" already has a different initialization contract.`);
+	}
+	/** Handled is the disjunction: one view claiming a notification must not hide it from another. */
+	#dispatchers(entry, methods) {
+		const handlers = {};
+		for (const method of methods) handlers[method] = (client, params, message) => {
+			let handled = false;
+			for (const lease of leasesOf(entry)) handled = (lease.notificationHandlers[method]?.(client, params, message) ?? false) || handled;
+			return handled;
+		};
+		return handlers;
+	}
+	/** Diagnostics broadcast rather than routed: `DocumentSync` already drops uris it does not hold. */
+	#fanOut(entry) {
+		return {
+			onConnected: () => {
+				entry.connected = true;
+				entry.readyAt = now();
+				this.#emit(entry, "ready", { durationMs: Math.round(entry.readyAt - entry.createdAt) });
+				for (const lease of leasesOf(entry)) lease.callbacks.onConnected();
+			},
+			onDiagnosticRefresh: () => {
+				for (const lease of leasesOf(entry)) lease.callbacks.onDiagnosticRefresh?.();
+			},
+			onReconnecting: (error) => {
+				entry.connected = false;
+				this.#emit(entry, "reconnecting", {
+					durationMs: Math.round(now() - entry.createdAt),
+					error,
+					reachedReady: entry.readyAt !== null
+				});
+				for (const lease of leasesOf(entry)) lease.callbacks.onReconnecting?.(error);
+			},
+			onUnavailable: () => {
+				entry.connected = false;
+				this.#retire(entry);
+				for (const lease of leasesOf(entry)) lease.callbacks.onUnavailable();
+			},
+			onPublishDiagnostics: (params) => {
+				for (const lease of leasesOf(entry)) lease.callbacks.onPublishDiagnostics(params);
+			},
+			onStatusChange: (status) => {
+				entry.status = status;
+				for (const lease of leasesOf(entry)) lease.callbacks.onStatusChange?.(status);
+			},
+			onError: (error) => {
+				this.#emit(entry, "error", {
+					durationMs: Math.round(now() - entry.createdAt),
+					error,
+					reachedReady: entry.readyAt !== null
+				});
+				for (const lease of leasesOf(entry)) lease.callbacks.onError?.(error);
+			}
+		};
+	}
+	/** A microtask, not a straight call: `acquire` runs inside the contribution's constructor. */
+	#replayTo(entry, lease) {
+		if (entry.status === "idle") return;
+		const status = entry.status;
+		const connected = entry.connected;
+		queueMicrotask(() => {
+			if (!entry.leases.has(lease)) return;
+			lease.callbacks.onStatusChange?.(status);
+			if (connected) lease.callbacks.onConnected();
+		});
+	}
+	#release(entry, lease) {
+		if (!entry.leases.delete(lease)) return;
+		this.#emit(entry, "released");
+		if (entry.leases.size > 0) return;
+		if (this.#entries.get(entry.key) !== entry) return;
+		entry.idleTimer = setTimeout(() => this.#closeIdle(entry), this.#idleGraceMs);
+	}
+	#closeIdle(entry) {
+		entry.idleTimer = null;
+		if (entry.leases.size > 0) return;
+		if (this.#entries.get(entry.key) !== entry) return;
+		this.#entries.delete(entry.key);
+		entry.connection.dispose();
+		this.#emit(entry, "closed", {
+			durationMs: Math.round(now() - entry.createdAt),
+			reachedReady: entry.readyAt !== null
+		});
+	}
+	#retire(entry) {
+		if (entry.idleTimer !== null) clearTimeout(entry.idleTimer);
+		entry.idleTimer = null;
+		if (this.#entries.get(entry.key) === entry) this.#entries.delete(entry.key);
+		entry.connection.dispose();
+		this.#emit(entry, "retired", {
+			durationMs: Math.round(now() - entry.createdAt),
+			reachedReady: entry.readyAt !== null
+		});
+	}
+	#reportUndispatchable(entry, lease) {
+		const methods = Object.keys(lease.notificationHandlers).filter((method) => !entry.notificationMethods.has(method));
+		if (methods.length === 0) return;
+		this.#emit(entry, "handler_ignored", { methods });
+	}
+	#emit(entry, kind, extra = {}) {
+		this.#onEvent?.({
+			key: entry.key,
+			kind,
+			leaseCount: entry.leases.size,
+			status: entry.status,
+			...extra
+		});
+	}
+};
+/** Snapshotted: a callback can release its own lease mid-iteration. */
+function leasesOf(entry) {
+	return Array.from(entry.leases);
+}
+function now() {
+	return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+function initializationContract(options) {
+	return {
+		capabilities: normalizeComparable(options.capabilities),
+		clientInfo: normalizeComparable(options.clientInfo),
+		initializationOptions: normalizeComparable(options.initializationOptions),
+		rootUri: options.rootUri
+	};
+}
+function normalizeComparable(value) {
+	if (Array.isArray(value)) return value.map(normalizeComparable);
+	if (!isRecord(value)) return value;
+	const normalized = {};
+	const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+	for (const key of keys) normalized[key] = normalizeComparable(value[key]);
+	return normalized;
+}
+function structurallyEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) || Array.isArray(right)) return equalArrays(left, right);
+	if (!isRecord(left) || !isRecord(right)) return false;
+	return equalRecords(left, right);
+}
+function equalArrays(left, right) {
+	if (!Array.isArray(left) || !Array.isArray(right)) return false;
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index += 1) if (!structurallyEqual(left[index], right[index])) return false;
+	return true;
+}
+function equalRecords(left, right) {
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!(key in right)) return false;
+		if (!structurallyEqual(left[key], right[key])) return false;
+	}
+	return true;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A request has one answer, so the first borrower that handles the method gives it; the methods
+* are fixed by the first borrower, like the notification methods.
+*/
+function requestDispatchers(entry, initial) {
+	const handlers = {};
+	for (const method of Object.keys(initial)) handlers[method] = (client, params, message) => {
+		const handler = leasesOf(entry).find((lease) => lease.serverRequestHandlers[method])?.serverRequestHandlers[method];
+		if (!handler) throw new Error(`No editor on this connection answers ${method}`);
+		return handler(client, params, message);
+	};
+	return handlers;
+}
+//#endregion
+export { LspConnectionPool };
+
+//# sourceMappingURL=lspConnectionPool.js.map

package/dist/lspConnectionPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lspConnectionPool.js","names":[],"sources":["../src/lspConnectionPool.ts"],"sourcesContent":["import type {\n  LspClient,\n  LspNotificationHandler,\n  LspServerRequestHandler,\n} from '@singapore-editor/lsp'\n\nimport {\n  LspConnection,\n  type LspConnectionCallbacks,\n  type LspConnectionLease,\n  type LspConnectionOptions,\n  type LspConnectionProvider,\n} from './lspConnection'\nimport type { LanguageServerStatus } from './types'\n\n/**\n * How long a connection with no borrowers is kept. A file switch drops the lease count to zero for a\n * tick or two on its way from one view to the next; the cost of holding on is one idle socket, the\n * cost of letting go early is another handshake against a server that may still be indexing.\n */\nconst DEFAULT_IDLE_GRACE_MS = 30_000\n\n/** What a pooled connection just did, for a host that wants to log it. */\nexport type LspConnectionPoolEvent = {\n  readonly kind:\n    | 'created'\n    | 'reused'\n    | 'ready'\n    | 'released'\n    | 'closed'\n    | 'retired'\n    | 'reconnecting'\n    | 'error'\n    | 'handler_ignored'\n  readonly key: string\n  readonly leaseCount: number\n  readonly status: LanguageServerStatus\n  /** Time to `initialize` for `ready`; the connection's life so far for `closed`, `retired` and `error`. */\n  readonly durationMs?: number\n  readonly reachedReady?: boolean\n  readonly error?: unknown\n  /** Methods a late borrower declared that this connection cannot dispatch. */\n  readonly methods?: readonly string[]\n}\n\nexport type LspConnectionPoolOptions = {\n  readonly idleGraceMs?: number\n  readonly onEvent?: (event: LspConnectionPoolEvent) => void\n}\n\ntype NotificationHandlers = Readonly<Record<string, LspNotificationHandler<LspClient>>>\ntype ServerRequestHandlers = Readonly<Record<string, LspServerRequestHandler<LspClient>>>\n\n/** Handlers are per borrower: the first one's are bound to a view the reader may have left. */\ntype ConnectionLease = {\n  readonly callbacks: LspConnectionCallbacks\n  readonly notificationHandlers: NotificationHandlers\n  readonly serverRequestHandlers: ServerRequestHandlers\n}\n\ntype PooledConnection = {\n  readonly initializationContract: ImmutableInitializationContract\n  readonly key: string\n  readonly leases: Set<ConnectionLease>\n  readonly createdAt: number\n  /** Fixed at construction, when the client reads the record. A later borrower outside it is a defect. */\n  readonly notificationMethods: ReadonlySet<string>\n  connection: LspConnection\n  status: LanguageServerStatus\n  connected: boolean\n  readyAt: number | null\n  idleTimer: ReturnType<typeof setTimeout> | null\n}\n\ntype ImmutableInitializationContract = {\n  readonly capabilities: unknown\n  readonly clientInfo: unknown\n  readonly initializationOptions: unknown\n  readonly rootUri: string | null\n}\n\n/**\n * One connection per key, outliving the views that borrow it. A view contribution is rebuilt on\n * every file switch, and a connection it owns dies with it — thirteen handshakes in twenty-two\n * seconds, measured. The key is opaque: how a server session is named is the host's vocabulary.\n */\nexport class LspConnectionPool {\n  readonly #entries = new Map<string, PooledConnection>()\n  readonly #idleGraceMs: number\n  readonly #onEvent?: (event: LspConnectionPoolEvent) => void\n\n  public constructor(options: LspConnectionPoolOptions = {}) {\n    this.#idleGraceMs = options.idleGraceMs ?? DEFAULT_IDLE_GRACE_MS\n    this.#onEvent = options.onEvent\n  }\n\n  /** A provider bound to one key, in the shape the plugin takes. */\n  public provider(key: string): LspConnectionProvider {\n    return { acquire: (options, callbacks) => this.acquire(key, options, callbacks) }\n  }\n\n  public acquire(\n    key: string,\n    options: LspConnectionOptions,\n    callbacks: LspConnectionCallbacks,\n  ): LspConnectionLease {\n    const existing = this.#entries.get(key)\n    if (existing) this.#assertCompatible(existing, options)\n\n    const entry = existing ?? this.#create(key, options)\n    if (entry.idleTimer !== null) {\n      clearTimeout(entry.idleTimer)\n      entry.idleTimer = null\n    }\n\n    const lease: ConnectionLease = {\n      callbacks,\n      notificationHandlers: options.notificationHandlers ?? {},\n      serverRequestHandlers: options.serverRequestHandlers ?? {},\n    }\n    this.#reportUndispatchable(entry, lease)\n    entry.leases.add(lease)\n    this.#emit(entry, existing ? 'reused' : 'created')\n    this.#replayTo(entry, lease)\n\n    return {\n      connection: entry.connection,\n      release: () => this.#release(entry, lease),\n    }\n  }\n\n  /** Closes every connection. For teardown and for tests, not for routine use. */\n  public dispose(): void {\n    for (const entry of this.#entries.values()) {\n      if (entry.idleTimer !== null) clearTimeout(entry.idleTimer)\n      entry.connection.dispose()\n    }\n    this.#entries.clear()\n  }\n\n  #create(key: string, options: LspConnectionOptions): PooledConnection {\n    const notificationMethods = new Set(Object.keys(options.notificationHandlers ?? {}))\n    const entry: PooledConnection = {\n      connected: false,\n      connection: null as unknown as LspConnection,\n      createdAt: now(),\n      idleTimer: null,\n      initializationContract: initializationContract(options),\n      key,\n      leases: new Set(),\n      notificationMethods,\n      readyAt: null,\n      status: 'idle',\n    }\n    // Assigned after the record exists because the callbacks close over it: the\n    // connection reports `loading` from inside `connect()`, which is before any\n    // `new LspConnection(...)` expression could have returned.\n    entry.connection = new LspConnection(\n      {\n        ...options,\n        notificationHandlers: this.#dispatchers(entry, notificationMethods),\n        serverRequestHandlers: requestDispatchers(entry, options.serverRequestHandlers ?? {}),\n      },\n      this.#fanOut(entry),\n    )\n    this.#entries.set(key, entry)\n    entry.connection.connect()\n\n    return entry\n  }\n\n  #assertCompatible(entry: PooledConnection, options: LspConnectionOptions): void {\n    const incoming = initializationContract(options)\n    if (structurallyEqual(entry.initializationContract, incoming)) return\n\n    throw new Error(\n      `LSP connection pool key \"${entry.key}\" already has a different initialization contract.`,\n    )\n  }\n\n  /** Handled is the disjunction: one view claiming a notification must not hide it from another. */\n  #dispatchers(entry: PooledConnection, methods: ReadonlySet<string>): NotificationHandlers {\n    const handlers: Record<string, LspNotificationHandler<LspClient>> = {}\n    for (const method of methods) {\n      handlers[method] = (client, params, message) => {\n        let handled = false\n        for (const lease of leasesOf(entry))\n          handled =\n            (lease.notificationHandlers[method]?.(client, params, message) ?? false) || handled\n\n        return handled\n      }\n    }\n\n    return handlers\n  }\n\n  /** Diagnostics broadcast rather than routed: `DocumentSync` already drops uris it does not hold. */\n  #fanOut(entry: PooledConnection): LspConnectionCallbacks {\n    return {\n      onConnected: () => {\n        entry.connected = true\n        entry.readyAt = now()\n        this.#emit(entry, 'ready', { durationMs: Math.round(entry.readyAt - entry.createdAt) })\n        for (const lease of leasesOf(entry)) lease.callbacks.onConnected()\n      },\n      onDiagnosticRefresh: () => {\n        for (const lease of leasesOf(entry)) lease.callbacks.onDiagnosticRefresh?.()\n      },\n      onReconnecting: (error) => {\n        entry.connected = false\n        this.#emit(entry, 'reconnecting', {\n          durationMs: Math.round(now() - entry.createdAt),\n          error,\n          reachedReady: entry.readyAt !== null,\n        })\n        for (const lease of leasesOf(entry)) lease.callbacks.onReconnecting?.(error)\n      },\n      onUnavailable: () => {\n        entry.connected = false\n        this.#retire(entry)\n        for (const lease of leasesOf(entry)) lease.callbacks.onUnavailable()\n      },\n      onPublishDiagnostics: (params) => {\n        for (const lease of leasesOf(entry)) lease.callbacks.onPublishDiagnostics(params)\n      },\n      onStatusChange: (status) => {\n        entry.status = status\n        for (const lease of leasesOf(entry)) lease.callbacks.onStatusChange?.(status)\n      },\n      onError: (error) => {\n        this.#emit(entry, 'error', {\n          durationMs: Math.round(now() - entry.createdAt),\n          error,\n          reachedReady: entry.readyAt !== null,\n        })\n        for (const lease of leasesOf(entry)) lease.callbacks.onError?.(error)\n      },\n    }\n  }\n\n  /** A microtask, not a straight call: `acquire` runs inside the contribution's constructor. */\n  #replayTo(entry: PooledConnection, lease: ConnectionLease): void {\n    if (entry.status === 'idle') return\n\n    const status = entry.status\n    const connected = entry.connected\n    queueMicrotask(() => {\n      if (!entry.leases.has(lease)) return\n\n      lease.callbacks.onStatusChange?.(status)\n      if (connected) lease.callbacks.onConnected()\n    })\n  }\n\n  #release(entry: PooledConnection, lease: ConnectionLease): void {\n    if (!entry.leases.delete(lease)) return\n\n    this.#emit(entry, 'released')\n    if (entry.leases.size > 0) return\n    if (this.#entries.get(entry.key) !== entry) return\n\n    entry.idleTimer = setTimeout(() => this.#closeIdle(entry), this.#idleGraceMs)\n  }\n\n  #closeIdle(entry: PooledConnection): void {\n    entry.idleTimer = null\n    if (entry.leases.size > 0) return\n    if (this.#entries.get(entry.key) !== entry) return\n\n    this.#entries.delete(entry.key)\n    entry.connection.dispose()\n    this.#emit(entry, 'closed', {\n      durationMs: Math.round(now() - entry.createdAt),\n      reachedReady: entry.readyAt !== null,\n    })\n  }\n\n  #retire(entry: PooledConnection): void {\n    if (entry.idleTimer !== null) clearTimeout(entry.idleTimer)\n    entry.idleTimer = null\n    if (this.#entries.get(entry.key) === entry) this.#entries.delete(entry.key)\n    entry.connection.dispose()\n    this.#emit(entry, 'retired', {\n      durationMs: Math.round(now() - entry.createdAt),\n      reachedReady: entry.readyAt !== null,\n    })\n  }\n\n  #reportUndispatchable(entry: PooledConnection, lease: ConnectionLease): void {\n    const methods = Object.keys(lease.notificationHandlers).filter(\n      (method) => !entry.notificationMethods.has(method),\n    )\n    if (methods.length === 0) return\n\n    this.#emit(entry, 'handler_ignored', { methods })\n  }\n\n  #emit(\n    entry: PooledConnection,\n    kind: LspConnectionPoolEvent['kind'],\n    extra: Omit<LspConnectionPoolEvent, 'kind' | 'key' | 'leaseCount' | 'status'> = {},\n  ): void {\n    this.#onEvent?.({\n      key: entry.key,\n      kind,\n      leaseCount: entry.leases.size,\n      status: entry.status,\n      ...extra,\n    })\n  }\n}\n\n/** Snapshotted: a callback can release its own lease mid-iteration. */\nfunction leasesOf(entry: PooledConnection): readonly ConnectionLease[] {\n  return Array.from(entry.leases)\n}\n\nfunction now(): number {\n  return typeof performance === 'undefined' ? Date.now() : performance.now()\n}\n\nfunction initializationContract(options: LspConnectionOptions): ImmutableInitializationContract {\n  return {\n    capabilities: normalizeComparable(options.capabilities),\n    clientInfo: normalizeComparable(options.clientInfo),\n    initializationOptions: normalizeComparable(options.initializationOptions),\n    rootUri: options.rootUri,\n  }\n}\n\nfunction normalizeComparable(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map(normalizeComparable)\n  if (!isRecord(value)) return value\n\n  const normalized: Record<string, unknown> = {}\n  const keys = Object.keys(value)\n    .filter((key) => value[key] !== undefined)\n    .sort()\n  for (const key of keys) normalized[key] = normalizeComparable(value[key])\n  return normalized\n}\n\nfunction structurallyEqual(left: unknown, right: unknown): boolean {\n  if (Object.is(left, right)) return true\n  if (Array.isArray(left) || Array.isArray(right)) return equalArrays(left, right)\n  if (!isRecord(left) || !isRecord(right)) return false\n  return equalRecords(left, right)\n}\n\nfunction equalArrays(left: unknown, right: unknown): boolean {\n  if (!Array.isArray(left) || !Array.isArray(right)) return false\n  if (left.length !== right.length) return false\n\n  for (let index = 0; index < left.length; index += 1) {\n    if (!structurallyEqual(left[index], right[index])) return false\n  }\n  return true\n}\n\nfunction equalRecords(left: Record<string, unknown>, right: Record<string, unknown>): boolean {\n  const leftKeys = Object.keys(left)\n  const rightKeys = Object.keys(right)\n  if (leftKeys.length !== rightKeys.length) return false\n\n  for (const key of leftKeys) {\n    if (!(key in right)) return false\n    if (!structurallyEqual(left[key], right[key])) return false\n  }\n  return true\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\n/**\n * A request has one answer, so the first borrower that handles the method gives it; the methods\n * are fixed by the first borrower, like the notification methods.\n */\nfunction requestDispatchers(\n  entry: PooledConnection,\n  initial: ServerRequestHandlers,\n): ServerRequestHandlers {\n  const handlers: Record<string, LspServerRequestHandler<LspClient>> = {}\n  for (const method of Object.keys(initial)) {\n    handlers[method] = (client, params, message) => {\n      const handler = leasesOf(entry).find((lease) => lease.serverRequestHandlers[method])\n        ?.serverRequestHandlers[method]\n      // An answer the server can mistake for an empty one is worse than an error it can report.\n      if (!handler) throw new Error(`No editor on this connection answers ${method}`)\n      return handler(client, params, message)\n    }\n  }\n  return handlers\n}\n"],"mappings":"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"}

package/dist/minimalEdits.d.ts

@@ -0,0 +1,21 @@
+import type { TextEdit } from '@singapore-editor/core';
+/**
+ * The longest replacement still worth re-diffing.
+ *
+ * Past this the comparison costs more than it saves: a reply that rewrites this much has left
+ * almost no anchor, decoration or fold inside the span to preserve, and the diff itself becomes the
+ * expensive part of formatting.
+ */
+export declare const REDIFF_LENGTH_LIMIT = 100000;
+/**
+ * Splits a replacement into edits covering only what differs from the text it overwrites.
+ *
+ * A formatter answers with the whole document, or a whole line, even when three characters moved.
+ * Applying that verbatim rewrites text that did not change, and every anchor, decoration, fold and
+ * selection inside the rewritten span dies with it — so the reply is compared against the buffer
+ * first and only the differences are handed on.
+ *
+ * `offset` is where `original` starts in the document, so the returned edits address the buffer.
+ */
+export declare function minimalReplacementEdits(original: string, replacement: string, offset: number): TextEdit[];
+//# sourceMappingURL=minimalEdits.d.ts.map

package/dist/minimalEdits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimalEdits.d.ts","sourceRoot":"","sources":["../src/minimalEdits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,SAAU,CAAA;AAkB1C;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,QAAQ,EAAE,CA6BZ"}

package/dist/minimalEdits.js

@@ -0,0 +1,181 @@
+//#region src/minimalEdits.ts
+/**
+* The longest replacement still worth re-diffing.
+*
+* Past this the comparison costs more than it saves: a reply that rewrites this much has left
+* almost no anchor, decoration or fold inside the span to preserve, and the diff itself becomes the
+* expensive part of formatting.
+*/
+var REDIFF_LENGTH_LIMIT = 1e5;
+/**
+* How far apart the two texts may be before the alignment is abandoned.
+*
+* One endpoint band per step is kept so the alignment can be walked back, so the memory held grows
+* with the square of this number. A reply differing by more than this is a rewrite rather than a
+* reformat, and is cheaper to apply whole.
+*/
+var REDIFF_STEP_LIMIT = 400;
+/**
+* Splits a replacement into edits covering only what differs from the text it overwrites.
+*
+* A formatter answers with the whole document, or a whole line, even when three characters moved.
+* Applying that verbatim rewrites text that did not change, and every anchor, decoration, fold and
+* selection inside the rewritten span dies with it — so the reply is compared against the buffer
+* first and only the differences are handed on.
+*
+* `offset` is where `original` starts in the document, so the returned edits address the buffer.
+*/
+function minimalReplacementEdits(original, replacement, offset) {
+	if (original === replacement) return [];
+	if (Math.max(original.length, replacement.length) > 1e5) return [wholeReplacement(original, replacement, offset)];
+	const originalLines = splitAfterLineBreaks(original);
+	const replacementLines = splitAfterLineBreaks(replacement);
+	const regions = changedLineRegions(originalLines, replacementLines);
+	if (!regions) return [wholeReplacement(original, replacement, offset)];
+	const originalStarts = lineStartOffsets(originalLines);
+	const replacementStarts = lineStartOffsets(replacementLines);
+	const edits = [];
+	for (const region of regions) {
+		const edit = narrowToDifference(original, originalStarts[region.originalStart] ?? 0, originalStarts[region.originalEnd] ?? original.length, replacement.slice(replacementStarts[region.replacementStart] ?? 0, replacementStarts[region.replacementEnd] ?? replacement.length), offset);
+		if (edit.from !== edit.to || edit.text.length > 0) edits.push(edit);
+	}
+	return edits;
+}
+function wholeReplacement(original, replacement, offset) {
+	return {
+		from: offset,
+		text: replacement,
+		to: offset + original.length
+	};
+}
+/**
+* Shrinks one region to the characters inside it that differ.
+*
+* Line alignment hands back the whole line an indentation change sits in; dropping what the two
+* sides still share turns that into the handful of characters the formatter actually touched. A
+* boundary steps back off a surrogate pair, because half a code point is not something the rest of
+* the editor can anchor to.
+*/
+function narrowToDifference(original, from, to, text, offset) {
+	const shared = Math.min(to - from, text.length);
+	let prefix = 0;
+	while (prefix < shared && original.charCodeAt(from + prefix) === text.charCodeAt(prefix)) prefix += 1;
+	if (prefix > 0 && isHighSurrogate(text.charCodeAt(prefix - 1))) prefix -= 1;
+	let suffix = 0;
+	while (suffix < shared - prefix && original.charCodeAt(to - 1 - suffix) === text.charCodeAt(text.length - 1 - suffix)) suffix += 1;
+	if (suffix > 0 && isLowSurrogate(text.charCodeAt(text.length - suffix))) suffix -= 1;
+	return {
+		from: offset + from + prefix,
+		text: text.slice(prefix, text.length - suffix),
+		to: offset + to - suffix
+	};
+}
+function isHighSurrogate(code) {
+	return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+	return code >= 56320 && code <= 57343;
+}
+/** Lines keep their terminator, so concatenating them back gives the text they came from. */
+function splitAfterLineBreaks(text) {
+	const lines = [];
+	let start = 0;
+	for (let index = 0; index < text.length; index += 1) {
+		if (text.charCodeAt(index) !== 10) continue;
+		lines.push(text.slice(start, index + 1));
+		start = index + 1;
+	}
+	lines.push(text.slice(start));
+	return lines;
+}
+function lineStartOffsets(lines) {
+	const starts = [0];
+	let offset = 0;
+	for (const line of lines) {
+		offset += line.length;
+		starts.push(offset);
+	}
+	return starts;
+}
+/**
+* Aligns two line sequences and returns the runs that do not correspond, or null when they lie
+* further apart than the step limit allows.
+*
+* The alignment is the shortest path that deletes original lines and inserts replacement ones,
+* taking equal lines for free; each step's furthest reach per diagonal is recorded so the path can
+* be walked back once the end is reached.
+*
+* Lines rather than characters, because a formatter's changes are line-shaped and aligning by line
+* costs a fraction of what aligning by character would; `narrowToDifference` recovers the
+* character-level precision afterwards, as a linear scan of one region.
+*/
+function changedLineRegions(original, replacement) {
+	const originalCount = original.length;
+	const replacementCount = replacement.length;
+	const stepLimit = Math.min(originalCount + replacementCount, REDIFF_STEP_LIMIT);
+	const band = stepLimit + 1;
+	const endpoints = new Int32Array(2 * band + 1);
+	const trace = [];
+	for (let step = 0; step <= stepLimit; step += 1) {
+		trace.push(endpoints.slice(band - step, band + step + 1));
+		for (let diagonal = -step; diagonal <= step; diagonal += 2) {
+			const afterInsert = endpoints[band + diagonal + 1] ?? 0;
+			const afterDelete = endpoints[band + diagonal - 1] ?? 0;
+			let x = diagonal === -step || diagonal !== step && afterDelete < afterInsert ? afterInsert : afterDelete + 1;
+			let y = x - diagonal;
+			while (x < originalCount && y < replacementCount && original[x] === replacement[y]) {
+				x += 1;
+				y += 1;
+			}
+			endpoints[band + diagonal] = x;
+			if (x >= originalCount && y >= replacementCount) return regionsFromTrace(trace, originalCount, replacementCount);
+		}
+	}
+	return null;
+}
+/**
+* Walks the recorded alignment back from the end, collecting every step that was not a match.
+*
+* Consecutive non-matching steps belong to one region: they are separated only once a run of equal
+* lines has been walked back over, which moves both cursors away from the region being built.
+*/
+function regionsFromTrace(trace, originalCount, replacementCount) {
+	const regions = [];
+	let open = null;
+	let x = originalCount;
+	let y = replacementCount;
+	for (let step = trace.length - 1; step > 0; step -= 1) {
+		const endpoints = trace[step];
+		if (!endpoints) break;
+		const diagonal = x - y;
+		const afterInsert = endpoints[diagonal + 1 + step] ?? 0;
+		const afterDelete = endpoints[diagonal - 1 + step] ?? 0;
+		const inserts = diagonal === -step || diagonal !== step && afterDelete < afterInsert;
+		const previousDiagonal = inserts ? diagonal + 1 : diagonal - 1;
+		const previousX = inserts ? afterInsert : afterDelete;
+		const previousY = previousX - previousDiagonal;
+		while (x > previousX && y > previousY) {
+			x -= 1;
+			y -= 1;
+		}
+		if (open && open.originalStart === x && open.replacementStart === y) {
+			open.originalStart = previousX;
+			open.replacementStart = previousY;
+		} else {
+			open = {
+				originalEnd: x,
+				originalStart: previousX,
+				replacementEnd: y,
+				replacementStart: previousY
+			};
+			regions.push(open);
+		}
+		x = previousX;
+		y = previousY;
+	}
+	return regions.reverse();
+}
+//#endregion
+export { REDIFF_LENGTH_LIMIT, minimalReplacementEdits };
+
+//# sourceMappingURL=minimalEdits.js.map

package/dist/minimalEdits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimalEdits.js","names":[],"sources":["../src/minimalEdits.ts"],"sourcesContent":["import type { TextEdit } from '@singapore-editor/core'\n\n/**\n * The longest replacement still worth re-diffing.\n *\n * Past this the comparison costs more than it saves: a reply that rewrites this much has left\n * almost no anchor, decoration or fold inside the span to preserve, and the diff itself becomes the\n * expensive part of formatting.\n */\nexport const REDIFF_LENGTH_LIMIT = 100_000\n\n/**\n * How far apart the two texts may be before the alignment is abandoned.\n *\n * One endpoint band per step is kept so the alignment can be walked back, so the memory held grows\n * with the square of this number. A reply differing by more than this is a rewrite rather than a\n * reformat, and is cheaper to apply whole.\n */\nconst REDIFF_STEP_LIMIT = 400\n\ntype LineRegion = {\n  originalStart: number\n  originalEnd: number\n  replacementStart: number\n  replacementEnd: number\n}\n\n/**\n * Splits a replacement into edits covering only what differs from the text it overwrites.\n *\n * A formatter answers with the whole document, or a whole line, even when three characters moved.\n * Applying that verbatim rewrites text that did not change, and every anchor, decoration, fold and\n * selection inside the rewritten span dies with it — so the reply is compared against the buffer\n * first and only the differences are handed on.\n *\n * `offset` is where `original` starts in the document, so the returned edits address the buffer.\n */\nexport function minimalReplacementEdits(\n  original: string,\n  replacement: string,\n  offset: number,\n): TextEdit[] {\n  if (original === replacement) return []\n  if (Math.max(original.length, replacement.length) > REDIFF_LENGTH_LIMIT) {\n    return [wholeReplacement(original, replacement, offset)]\n  }\n\n  const originalLines = splitAfterLineBreaks(original)\n  const replacementLines = splitAfterLineBreaks(replacement)\n  const regions = changedLineRegions(originalLines, replacementLines)\n  if (!regions) return [wholeReplacement(original, replacement, offset)]\n\n  const originalStarts = lineStartOffsets(originalLines)\n  const replacementStarts = lineStartOffsets(replacementLines)\n\n  const edits: TextEdit[] = []\n  for (const region of regions) {\n    const edit = narrowToDifference(\n      original,\n      originalStarts[region.originalStart] ?? 0,\n      originalStarts[region.originalEnd] ?? original.length,\n      replacement.slice(\n        replacementStarts[region.replacementStart] ?? 0,\n        replacementStarts[region.replacementEnd] ?? replacement.length,\n      ),\n      offset,\n    )\n    if (edit.from !== edit.to || edit.text.length > 0) edits.push(edit)\n  }\n  return edits\n}\n\nfunction wholeReplacement(original: string, replacement: string, offset: number): TextEdit {\n  return { from: offset, text: replacement, to: offset + original.length }\n}\n\n/**\n * Shrinks one region to the characters inside it that differ.\n *\n * Line alignment hands back the whole line an indentation change sits in; dropping what the two\n * sides still share turns that into the handful of characters the formatter actually touched. A\n * boundary steps back off a surrogate pair, because half a code point is not something the rest of\n * the editor can anchor to.\n */\nfunction narrowToDifference(\n  original: string,\n  from: number,\n  to: number,\n  text: string,\n  offset: number,\n): TextEdit {\n  const shared = Math.min(to - from, text.length)\n\n  let prefix = 0\n  while (prefix < shared && original.charCodeAt(from + prefix) === text.charCodeAt(prefix)) {\n    prefix += 1\n  }\n  if (prefix > 0 && isHighSurrogate(text.charCodeAt(prefix - 1))) prefix -= 1\n\n  let suffix = 0\n  while (\n    suffix < shared - prefix &&\n    original.charCodeAt(to - 1 - suffix) === text.charCodeAt(text.length - 1 - suffix)\n  ) {\n    suffix += 1\n  }\n  if (suffix > 0 && isLowSurrogate(text.charCodeAt(text.length - suffix))) suffix -= 1\n\n  return {\n    from: offset + from + prefix,\n    text: text.slice(prefix, text.length - suffix),\n    to: offset + to - suffix,\n  }\n}\n\nfunction isHighSurrogate(code: number): boolean {\n  return code >= 0xd800 && code <= 0xdbff\n}\n\nfunction isLowSurrogate(code: number): boolean {\n  return code >= 0xdc00 && code <= 0xdfff\n}\n\n/** Lines keep their terminator, so concatenating them back gives the text they came from. */\nfunction splitAfterLineBreaks(text: string): string[] {\n  const lines: string[] = []\n  let start = 0\n  for (let index = 0; index < text.length; index += 1) {\n    if (text.charCodeAt(index) !== 10) continue\n\n    lines.push(text.slice(start, index + 1))\n    start = index + 1\n  }\n  lines.push(text.slice(start))\n  return lines\n}\n\nfunction lineStartOffsets(lines: readonly string[]): number[] {\n  const starts = [0]\n  let offset = 0\n  for (const line of lines) {\n    offset += line.length\n    starts.push(offset)\n  }\n  return starts\n}\n\n/**\n * Aligns two line sequences and returns the runs that do not correspond, or null when they lie\n * further apart than the step limit allows.\n *\n * The alignment is the shortest path that deletes original lines and inserts replacement ones,\n * taking equal lines for free; each step's furthest reach per diagonal is recorded so the path can\n * be walked back once the end is reached.\n *\n * Lines rather than characters, because a formatter's changes are line-shaped and aligning by line\n * costs a fraction of what aligning by character would; `narrowToDifference` recovers the\n * character-level precision afterwards, as a linear scan of one region.\n */\nfunction changedLineRegions(\n  original: readonly string[],\n  replacement: readonly string[],\n): LineRegion[] | null {\n  const originalCount = original.length\n  const replacementCount = replacement.length\n  const stepLimit = Math.min(originalCount + replacementCount, REDIFF_STEP_LIMIT)\n  // A diagonal is reachable only after as many steps as it is far from the origin, so the band of\n  // live endpoints never widens past the step limit.\n  const band = stepLimit + 1\n  const endpoints = new Int32Array(2 * band + 1)\n  const trace: Int32Array[] = []\n\n  for (let step = 0; step <= stepLimit; step += 1) {\n    trace.push(endpoints.slice(band - step, band + step + 1))\n\n    for (let diagonal = -step; diagonal <= step; diagonal += 2) {\n      const afterInsert = endpoints[band + diagonal + 1] ?? 0\n      const afterDelete = endpoints[band + diagonal - 1] ?? 0\n      const inserts = diagonal === -step || (diagonal !== step && afterDelete < afterInsert)\n      let x = inserts ? afterInsert : afterDelete + 1\n      let y = x - diagonal\n      while (x < originalCount && y < replacementCount && original[x] === replacement[y]) {\n        x += 1\n        y += 1\n      }\n      endpoints[band + diagonal] = x\n\n      if (x >= originalCount && y >= replacementCount) {\n        return regionsFromTrace(trace, originalCount, replacementCount)\n      }\n    }\n  }\n\n  return null\n}\n\n/**\n * Walks the recorded alignment back from the end, collecting every step that was not a match.\n *\n * Consecutive non-matching steps belong to one region: they are separated only once a run of equal\n * lines has been walked back over, which moves both cursors away from the region being built.\n */\nfunction regionsFromTrace(\n  trace: readonly Int32Array[],\n  originalCount: number,\n  replacementCount: number,\n): LineRegion[] {\n  const regions: LineRegion[] = []\n  let open: LineRegion | null = null\n  let x = originalCount\n  let y = replacementCount\n\n  for (let step = trace.length - 1; step > 0; step -= 1) {\n    const endpoints = trace[step]\n    if (!endpoints) break\n\n    const diagonal = x - y\n    const afterInsert = endpoints[diagonal + 1 + step] ?? 0\n    const afterDelete = endpoints[diagonal - 1 + step] ?? 0\n    const inserts = diagonal === -step || (diagonal !== step && afterDelete < afterInsert)\n    const previousDiagonal = inserts ? diagonal + 1 : diagonal - 1\n    const previousX = inserts ? afterInsert : afterDelete\n    const previousY = previousX - previousDiagonal\n\n    while (x > previousX && y > previousY) {\n      x -= 1\n      y -= 1\n    }\n\n    if (open && open.originalStart === x && open.replacementStart === y) {\n      open.originalStart = previousX\n      open.replacementStart = previousY\n    } else {\n      open = {\n        originalEnd: x,\n        originalStart: previousX,\n        replacementEnd: y,\n        replacementStart: previousY,\n      }\n      regions.push(open)\n    }\n\n    x = previousX\n    y = previousY\n  }\n\n  return regions.reverse()\n}\n"],"mappings":";;;;;;;;AASA,IAAa,sBAAsB;;;;;;;;AASnC,IAAM,oBAAoB;;;;;;;;;;;AAmB1B,SAAgB,wBACd,UACA,aACA,QACY;CACZ,IAAI,aAAa,aAAa,OAAO,CAAC;CACtC,IAAI,KAAK,IAAI,SAAS,QAAQ,YAAY,MAAM,IAAA,KAC9C,OAAO,CAAC,iBAAiB,UAAU,aAAa,MAAM,CAAC;CAGzD,MAAM,gBAAgB,qBAAqB,QAAQ;CACnD,MAAM,mBAAmB,qBAAqB,WAAW;CACzD,MAAM,UAAU,mBAAmB,eAAe,gBAAgB;CAClE,IAAI,CAAC,SAAS,OAAO,CAAC,iBAAiB,UAAU,aAAa,MAAM,CAAC;CAErE,MAAM,iBAAiB,iBAAiB,aAAa;CACrD,MAAM,oBAAoB,iBAAiB,gBAAgB;CAE3D,MAAM,QAAoB,CAAC;CAC3B,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,OAAO,mBACX,UACA,eAAe,OAAO,kBAAkB,GACxC,eAAe,OAAO,gBAAgB,SAAS,QAC/C,YAAY,MACV,kBAAkB,OAAO,qBAAqB,GAC9C,kBAAkB,OAAO,mBAAmB,YAAY,MAC1D,GACA,MACF;EACA,IAAI,KAAK,SAAS,KAAK,MAAM,KAAK,KAAK,SAAS,GAAG,MAAM,KAAK,IAAI;CACpE;CACA,OAAO;AACT;AAEA,SAAS,iBAAiB,UAAkB,aAAqB,QAA0B;CACzF,OAAO;EAAE,MAAM;EAAQ,MAAM;EAAa,IAAI,SAAS,SAAS;CAAO;AACzE;;;;;;;;;AAUA,SAAS,mBACP,UACA,MACA,IACA,MACA,QACU;CACV,MAAM,SAAS,KAAK,IAAI,KAAK,MAAM,KAAK,MAAM;CAE9C,IAAI,SAAS;CACb,OAAO,SAAS,UAAU,SAAS,WAAW,OAAO,MAAM,MAAM,KAAK,WAAW,MAAM,GACrF,UAAU;CAEZ,IAAI,SAAS,KAAK,gBAAgB,KAAK,WAAW,SAAS,CAAC,CAAC,GAAG,UAAU;CAE1E,IAAI,SAAS;CACb,OACE,SAAS,SAAS,UAClB,SAAS,WAAW,KAAK,IAAI,MAAM,MAAM,KAAK,WAAW,KAAK,SAAS,IAAI,MAAM,GAEjF,UAAU;CAEZ,IAAI,SAAS,KAAK,eAAe,KAAK,WAAW,KAAK,SAAS,MAAM,CAAC,GAAG,UAAU;CAEnF,OAAO;EACL,MAAM,SAAS,OAAO;EACtB,MAAM,KAAK,MAAM,QAAQ,KAAK,SAAS,MAAM;EAC7C,IAAI,SAAS,KAAK;CACpB;AACF;AAEA,SAAS,gBAAgB,MAAuB;CAC9C,OAAO,QAAQ,SAAU,QAAQ;AACnC;AAEA,SAAS,eAAe,MAAuB;CAC7C,OAAO,QAAQ,SAAU,QAAQ;AACnC;;AAGA,SAAS,qBAAqB,MAAwB;CACpD,MAAM,QAAkB,CAAC;CACzB,IAAI,QAAQ;CACZ,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;EACnD,IAAI,KAAK,WAAW,KAAK,MAAM,IAAI;EAEnC,MAAM,KAAK,KAAK,MAAM,OAAO,QAAQ,CAAC,CAAC;EACvC,QAAQ,QAAQ;CAClB;CACA,MAAM,KAAK,KAAK,MAAM,KAAK,CAAC;CAC5B,OAAO;AACT;AAEA,SAAS,iBAAiB,OAAoC;CAC5D,MAAM,SAAS,CAAC,CAAC;CACjB,IAAI,SAAS;CACb,KAAK,MAAM,QAAQ,OAAO;EACxB,UAAU,KAAK;EACf,OAAO,KAAK,MAAM;CACpB;CACA,OAAO;AACT;;;;;;;;;;;;;AAcA,SAAS,mBACP,UACA,aACqB;CACrB,MAAM,gBAAgB,SAAS;CAC/B,MAAM,mBAAmB,YAAY;CACrC,MAAM,YAAY,KAAK,IAAI,gBAAgB,kBAAkB,iBAAiB;CAG9E,MAAM,OAAO,YAAY;CACzB,MAAM,YAAY,IAAI,WAAW,IAAI,OAAO,CAAC;CAC7C,MAAM,QAAsB,CAAC;CAE7B,KAAK,IAAI,OAAO,GAAG,QAAQ,WAAW,QAAQ,GAAG;EAC/C,MAAM,KAAK,UAAU,MAAM,OAAO,MAAM,OAAO,OAAO,CAAC,CAAC;EAExD,KAAK,IAAI,WAAW,CAAC,MAAM,YAAY,MAAM,YAAY,GAAG;GAC1D,MAAM,cAAc,UAAU,OAAO,WAAW,MAAM;GACtD,MAAM,cAAc,UAAU,OAAO,WAAW,MAAM;GAEtD,IAAI,IADY,aAAa,CAAC,QAAS,aAAa,QAAQ,cAAc,cACxD,cAAc,cAAc;GAC9C,IAAI,IAAI,IAAI;GACZ,OAAO,IAAI,iBAAiB,IAAI,oBAAoB,SAAS,OAAO,YAAY,IAAI;IAClF,KAAK;IACL,KAAK;GACP;GACA,UAAU,OAAO,YAAY;GAE7B,IAAI,KAAK,iBAAiB,KAAK,kBAC7B,OAAO,iBAAiB,OAAO,eAAe,gBAAgB;EAElE;CACF;CAEA,OAAO;AACT;;;;;;;AAQA,SAAS,iBACP,OACA,eACA,kBACc;CACd,MAAM,UAAwB,CAAC;CAC/B,IAAI,OAA0B;CAC9B,IAAI,IAAI;CACR,IAAI,IAAI;CAER,KAAK,IAAI,OAAO,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG;EACrD,MAAM,YAAY,MAAM;EACxB,IAAI,CAAC,WAAW;EAEhB,MAAM,WAAW,IAAI;EACrB,MAAM,cAAc,UAAU,WAAW,IAAI,SAAS;EACtD,MAAM,cAAc,UAAU,WAAW,IAAI,SAAS;EACtD,MAAM,UAAU,aAAa,CAAC,QAAS,aAAa,QAAQ,cAAc;EAC1E,MAAM,mBAAmB,UAAU,WAAW,IAAI,WAAW;EAC7D,MAAM,YAAY,UAAU,cAAc;EAC1C,MAAM,YAAY,YAAY;EAE9B,OAAO,IAAI,aAAa,IAAI,WAAW;GACrC,KAAK;GACL,KAAK;EACP;EAEA,IAAI,QAAQ,KAAK,kBAAkB,KAAK,KAAK,qBAAqB,GAAG;GACnE,KAAK,gBAAgB;GACrB,KAAK,mBAAmB;EAC1B,OAAO;GACL,OAAO;IACL,aAAa;IACb,eAAe;IACf,gBAAgB;IAChB,kBAAkB;GACpB;GACA,QAAQ,KAAK,IAAI;EACnB;EAEA,IAAI;EACJ,IAAI;CACN;CAEA,OAAO,QAAQ,QAAQ;AACzB"}

package/dist/paths.d.ts

@@ -0,0 +1,6 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+export declare function sourcePathToFileName(path: string): string;
+export declare function pathOrUriToDocumentUri(pathOrUri: string): lsp.DocumentUri;
+export declare function fileNameToDocumentUri(fileName: string): lsp.DocumentUri;
+export declare function documentUriToFileName(uri: string): string | null;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAA;AAE1D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,WAAW,CAMzE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,WAAW,CAGvE;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQhE"}

package/dist/paths.js

@@ -0,0 +1,38 @@
+//#region src/paths.ts
+function sourcePathToFileName(path) {
+	if (hasUriScheme(path)) return documentUriToFileName(path) ?? normalizeFileNamePath(path);
+	return normalizeFileNamePath(path);
+}
+function pathOrUriToDocumentUri(pathOrUri) {
+	if (!hasUriScheme(pathOrUri)) return fileNameToDocumentUri(sourcePathToFileName(pathOrUri));
+	const fileName = documentUriToFileName(pathOrUri);
+	if (!fileName) return pathOrUri;
+	return fileNameToDocumentUri(fileName);
+}
+function fileNameToDocumentUri(fileName) {
+	return `file://${encodePathname(normalizeFileNamePath(fileName))}`;
+}
+function documentUriToFileName(uri) {
+	try {
+		const url = new URL(uri);
+		if (url.protocol !== "file:") return null;
+		return normalizeFileNamePath(decodeURIComponent(url.pathname));
+	} catch {
+		return null;
+	}
+}
+function normalizeFileNamePath(path) {
+	const normalized = path.replaceAll("\\", "/").replace(/^\/+/, "");
+	if (!normalized) return "/";
+	return `/${normalized}`;
+}
+function encodePathname(pathname) {
+	return pathname.split("/").map((part, index) => index === 0 && part === "" ? "" : encodeURIComponent(part)).join("/");
+}
+function hasUriScheme(value) {
+	return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value);
+}
+//#endregion
+export { documentUriToFileName, fileNameToDocumentUri, pathOrUriToDocumentUri, sourcePathToFileName };
+
+//# sourceMappingURL=paths.js.map

package/dist/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","names":[],"sources":["../src/paths.ts"],"sourcesContent":["import type * as lsp from 'vscode-languageserver-protocol'\n\nexport function sourcePathToFileName(path: string): string {\n  if (hasUriScheme(path)) return documentUriToFileName(path) ?? normalizeFileNamePath(path)\n  return normalizeFileNamePath(path)\n}\n\nexport function pathOrUriToDocumentUri(pathOrUri: string): lsp.DocumentUri {\n  if (!hasUriScheme(pathOrUri)) return fileNameToDocumentUri(sourcePathToFileName(pathOrUri))\n\n  const fileName = documentUriToFileName(pathOrUri)\n  if (!fileName) return pathOrUri\n  return fileNameToDocumentUri(fileName)\n}\n\nexport function fileNameToDocumentUri(fileName: string): lsp.DocumentUri {\n  const normalized = normalizeFileNamePath(fileName)\n  return `file://${encodePathname(normalized)}`\n}\n\nexport function documentUriToFileName(uri: string): string | null {\n  try {\n    const url = new URL(uri)\n    if (url.protocol !== 'file:') return null\n    return normalizeFileNamePath(decodeURIComponent(url.pathname))\n  } catch {\n    return null\n  }\n}\n\nfunction normalizeFileNamePath(path: string): string {\n  const normalized = path.replaceAll('\\\\', '/').replace(/^\\/+/, '')\n  if (!normalized) return '/'\n  return `/${normalized}`\n}\n\nfunction encodePathname(pathname: string): string {\n  return pathname\n    .split('/')\n    .map((part, index) => (index === 0 && part === '' ? '' : encodeURIComponent(part)))\n    .join('/')\n}\n\nfunction hasUriScheme(value: string): boolean {\n  return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)\n}\n"],"mappings":";AAEA,SAAgB,qBAAqB,MAAsB;CACzD,IAAI,aAAa,IAAI,GAAG,OAAO,sBAAsB,IAAI,KAAK,sBAAsB,IAAI;CACxF,OAAO,sBAAsB,IAAI;AACnC;AAEA,SAAgB,uBAAuB,WAAoC;CACzE,IAAI,CAAC,aAAa,SAAS,GAAG,OAAO,sBAAsB,qBAAqB,SAAS,CAAC;CAE1F,MAAM,WAAW,sBAAsB,SAAS;CAChD,IAAI,CAAC,UAAU,OAAO;CACtB,OAAO,sBAAsB,QAAQ;AACvC;AAEA,SAAgB,sBAAsB,UAAmC;CAEvE,OAAO,UAAU,eADE,sBAAsB,QACT,CAAU;AAC5C;AAEA,SAAgB,sBAAsB,KAA4B;CAChE,IAAI;EACF,MAAM,MAAM,IAAI,IAAI,GAAG;EACvB,IAAI,IAAI,aAAa,SAAS,OAAO;EACrC,OAAO,sBAAsB,mBAAmB,IAAI,QAAQ,CAAC;CAC/D,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,sBAAsB,MAAsB;CACnD,MAAM,aAAa,KAAK,WAAW,MAAM,GAAG,CAAC,CAAC,QAAQ,QAAQ,EAAE;CAChE,IAAI,CAAC,YAAY,OAAO;CACxB,OAAO,IAAI;AACb;AAEA,SAAS,eAAe,UAA0B;CAChD,OAAO,SACJ,MAAM,GAAG,CAAC,CACV,KAAK,MAAM,UAAW,UAAU,KAAK,SAAS,KAAK,KAAK,mBAAmB,IAAI,CAAE,CAAC,CAClF,KAAK,GAAG;AACb;AAEA,SAAS,aAAa,OAAwB;CAC5C,OAAO,4BAA4B,KAAK,KAAK;AAC/C"}