@pierre/diffs 1.3.6 → 1.4.1

package/dist/editor/EditStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditStateManager.d.ts","names":[],"sources":["../../src/editor/EditStateManager.ts"],"mappings":";;;;;;UAcU,sBAAA,eACM,UAAA;EAGd,QAAA,GAAW,YAAA,CAAa,KAAA,EAAO,WAAA;EAC/B,QAAA,GAAW,IAAA,CAAK,YAAA;EAChB,MAAA,GAAS,eAAA;AAAA;AAAA,UAGM,sBAAA,gCAEP,sBAAsB,SAAS,WAAA;EACvC,IAAA;EACA,WAAA;AAAA;AAAA,UAGe,0BAAA,gCAEP,sBAAA,cAAoC,WAAA;EAC5C,IAAA;EACA,WAAA,GAAc,2BAAA;AAAA;AAAA,KAGJ,kBAAA,eACI,UAAA,GAAa,UAAA,2BAEzB,sBAAA,CAAuB,KAAA,EAAO,WAAA,KAC/B,KAAA,kBACG,IAAA,CAAK,sBAAA,4BACL,IAAA,CAAK,0BAAA;;cAuHL,qBAAA;EAAA;EAhJJ;EAqJA,QAAA,eAAuB,UAAA,sBACrB,IAAA,EAAM,KAAA,EACN,YAAA,UACA,KAAA,EAAO,MAAA,CAAO,KAAA,EAAO,WAAA,EAAa,KAAA,GAClC,YAAA,GAAe,kBAAA,CAAmB,KAAA,EAAO,WAAA,IACxC,kBAAA,CAAmB,KAAA,EAAO,WAAA;EA1JL;;;;EA8KxB,WAAA,qBACE,YAAA,UACA,KAAA,EAAO,MAAA,SAAe,WAAA,EAAa,KAAA,GACnC,OAAA;EA/KF;;;AAAwB;EAwLxB,eAAA,qBACE,YAAA,UACA,KAAA,EAAO,MAAA,cAAoB,WAAA,EAAa,KAAA,GACxC,OAAA;EAxLmC;EA8LrC,GAAA,eAAkB,UAAA,eAChB,IAAA,EAAM,KAAA,EACN,YAAA,WACC,SAAA,CAAU,KAAA,EAAO,WAAA;EA/LU;EAwM9B,KAAA,CACE,IAAA,EAAM,UAAA,EACN,YAAA,UACA,KAAA,GAAQ,qBAAA;EA3MF;EAmNR,QAAA;EAKA,WAAA,CAAY,QAAA;AAAA;AAAA,UAMG,qBAAA;EACf,QAAA;EACA,OAAA;EACA,MAAA;EACA,UAAA;EACA,IAAA;AAAA;AAAA,iBAGc,oBAAA,CAAqB,KAAA,EAAO,eAAA,GAAkB,eAAe;AAAA,iBAW7D,kBAAA,eAAiC,UAAA,eAC/C,OAAA,EAAS,kBAAA,CAAmB,KAAA,EAAO,WAAA,IAClC,SAAA,CAAU,KAAA,EAAO,WAAA;AAAA,cAmCP,gBAAA,EAAkB,qBACF"}

package/dist/editor/EditStateManager.js

@@ -0,0 +1,135 @@
+import LRUMapPkg from "lru_map";
+//#region src/editor/EditStateManager.ts
+const DEFAULT_EDIT_STATE_CAPACITY = 100;
+/** Owns dormant edit state and active-key exclusion for one editor type. */
+var EditStateManagerNamespace = class {
+	type;
+	#states = new LRUMapPkg.LRUMap(DEFAULT_EDIT_STATE_CAPACITY);
+	#sessions = /* @__PURE__ */ new Map();
+	constructor(type) {
+		this.type = type;
+	}
+	activate(editStateKey, owner, initialState) {
+		const activeSession = this.#sessions.get(editStateKey);
+		if (activeSession != null && activeSession.owner !== owner) throw new Error(`Editor: editStateKey "${editStateKey}" is already attached to another editor`);
+		if (activeSession != null) {
+			if (initialState != null) activeSession.session = initialState;
+			return activeSession.session;
+		}
+		const retainedState = this.#states.delete(editStateKey);
+		const emptyState = { type: this.type };
+		const state = initialState ?? retainedState ?? emptyState;
+		this.#sessions.set(editStateKey, {
+			owner,
+			session: state
+		});
+		return state;
+	}
+	release(editStateKey, owner, discard = false) {
+		const activeSession = this.#sessions.get(editStateKey);
+		if (activeSession?.owner !== owner) return;
+		this.#sessions.delete(editStateKey);
+		if (discard) return;
+		const retainedState = toManagedEditState(activeSession.session);
+		if (retainedState != null) this.#states.set(editStateKey, retainedState);
+	}
+	get(editStateKey) {
+		const activeSession = this.#sessions.get(editStateKey);
+		if (activeSession != null) {
+			const state = toManagedEditState(activeSession.session);
+			if (state == null) return;
+			return state;
+		}
+		return this.#states.find(editStateKey);
+	}
+	/** Clear dormant state for a key. Omit `parts` to clear everything. */
+	clear(editStateKey, parts) {
+		if (this.#sessions.has(editStateKey)) return false;
+		const state = this.#states.find(editStateKey);
+		if (state == null) return false;
+		if (parts == null || parts.document === true) this.#states.delete(editStateKey);
+		else applyClearEditStateOptions(state, parts);
+		return true;
+	}
+	clearAll() {
+		this.#states.clear();
+	}
+	setCapacity(capacity) {
+		if (!Number.isSafeInteger(capacity) || capacity < 1) throw new RangeError("EditStateManager: capacity must be a positive integer");
+		while (this.#states.size > capacity) this.#states.shift();
+		this.#states.limit = capacity;
+	}
+};
+/** Keeps file and diff edit state in independent persistence domains. */
+var EditStateManagerClass = class {
+	#files = new EditStateManagerNamespace("file");
+	#diffs = new EditStateManagerNamespace("file-diff");
+	/** Mark a keyed session as active and return its initial or stored state. */
+	activate(type, editStateKey, owner, initialState) {
+		return type === "file" ? this.#files.activate(editStateKey, owner, initialState) : this.#diffs.activate(editStateKey, owner, initialState);
+	}
+	/**
+	* Stop tracking this file session as active and store its current state,
+	* unless `discard` is true.
+	*/
+	releaseFile(editStateKey, owner, discard = false) {
+		this.#files.release(editStateKey, owner, discard);
+	}
+	/**
+	* Stop tracking this diff session as active and store its current state,
+	* unless `discard` is true.
+	*/
+	releaseFileDiff(editStateKey, owner, discard = false) {
+		this.#diffs.release(editStateKey, owner, discard);
+	}
+	/** Return current state for an active or dormant editing session. */
+	get(type, editStateKey) {
+		return type === "file" ? this.#files.get(editStateKey) : this.#diffs.get(editStateKey);
+	}
+	/** Clear a dormant session, returning false when it is active or missing. */
+	clear(type, editStateKey, parts) {
+		return type === "file" ? this.#files.clear(editStateKey, parts) : this.#diffs.clear(editStateKey, parts);
+	}
+	/** Clear all dormant sessions without affecting active editors. */
+	clearAll() {
+		this.#files.clearAll();
+		this.#diffs.clearAll();
+	}
+	setCapacity(capacity) {
+		this.#files.setCapacity(capacity);
+		this.#diffs.setCapacity(capacity);
+	}
+};
+function cloneEditorViewState(state) {
+	return {
+		selections: state.selections?.map((selection) => ({
+			...selection,
+			start: { ...selection.start },
+			end: { ...selection.end }
+		})),
+		view: state.view == null ? void 0 : { ...state.view }
+	};
+}
+function toManagedEditState(session) {
+	if (session.document == null || session.fileInfo == null) return;
+	if (session.type === "file") {
+		session.editor ??= {};
+		return session;
+	}
+	if (session.diffSession == null) return;
+	session.editor ??= {};
+	return session;
+}
+function applyClearEditStateOptions(session, parts) {
+	if (session == null) return;
+	if (parts.history === true) session.document?.clearHistory();
+	if (session.editor != null) {
+		if (parts.editor === true || parts.selections === true) session.editor.selections = void 0;
+		if (parts.editor === true || parts.view === true) session.editor.view = void 0;
+	}
+}
+const EditStateManager = new EditStateManagerClass();
+//#endregion
+export { EditStateManager, cloneEditorViewState, toManagedEditState };
+
+//# sourceMappingURL=EditStateManager.js.map

package/dist/editor/EditStateManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditStateManager.js","names":["#sessions","#states","#files","#diffs"],"sources":["../../src/editor/EditStateManager.ts"],"sourcesContent":["import LRUMapPkg from 'lru_map';\n\nimport type { FileContents } from '../types';\nimport type { Editor } from './editor';\nimport { TextDocument } from './textDocument';\nimport type {\n  EditorType,\n  EditorViewState,\n  EditState,\n  RetainedDiffSessionSnapshot,\n} from './types';\n\nconst DEFAULT_EDIT_STATE_CAPACITY = 100;\n\ninterface ManagedEditSessionBase<\n  EType extends EditorType,\n  LAnnotation = unknown,\n> {\n  document?: TextDocument<EType, LAnnotation>;\n  fileInfo?: Pick<FileContents, 'lang' | 'name'>;\n  editor?: EditorViewState;\n}\n\nexport interface ManagedFileEditSession<\n  LAnnotation = unknown,\n> extends ManagedEditSessionBase<'file', LAnnotation> {\n  type: 'file';\n  diffSession?: never;\n}\n\nexport interface ManagedFileDiffEditSession<\n  LAnnotation = unknown,\n> extends ManagedEditSessionBase<'file-diff', LAnnotation> {\n  type: 'file-diff';\n  diffSession?: RetainedDiffSessionSnapshot;\n}\n\nexport type ManagedEditSession<\n  EType extends EditorType = EditorType,\n  LAnnotation = unknown,\n> = ManagedEditSessionBase<EType, LAnnotation> &\n  (EType extends 'file'\n    ? Pick<ManagedFileEditSession, 'type' | 'diffSession'>\n    : Pick<ManagedFileDiffEditSession, 'type' | 'diffSession'>);\n\ninterface EditStateManagerSession<K extends EditorType> {\n  owner: Editor<K, unknown>;\n  session: ManagedEditSession<K>;\n}\n\n/** Owns dormant edit state and active-key exclusion for one editor type. */\nclass EditStateManagerNamespace<EType extends EditorType> {\n  #states = new LRUMapPkg.LRUMap<string, EditState<EType>>(\n    DEFAULT_EDIT_STATE_CAPACITY\n  );\n  #sessions = new Map<string, EditStateManagerSession<EType>>();\n\n  constructor(readonly type: EType) {}\n\n  activate<LAnnotation, Caret>(\n    editStateKey: string,\n    owner: Editor<EType, LAnnotation, Caret>,\n    initialState?: ManagedEditSession<EType, LAnnotation>\n  ): ManagedEditSession<EType, LAnnotation> {\n    const activeSession = this.#sessions.get(editStateKey);\n    if (activeSession != null && activeSession.owner !== owner) {\n      throw new Error(\n        `Editor: editStateKey \"${editStateKey}\" is already attached to another editor`\n      );\n    }\n    if (activeSession != null) {\n      if (initialState != null) {\n        activeSession.session = initialState;\n      }\n      return activeSession.session as ManagedEditSession<EType, LAnnotation>;\n    }\n    const retainedState = this.#states.delete(editStateKey);\n    const emptyState = {\n      type: this.type,\n    } as ManagedEditSession<EType>;\n    const state = (initialState ??\n      retainedState ??\n      emptyState) as ManagedEditSession<EType, LAnnotation>;\n    this.#sessions.set(editStateKey, {\n      owner: owner as Editor<EType, unknown>,\n      session: state as ManagedEditSession<EType>,\n    });\n    return state;\n  }\n\n  release<LAnnotation, Caret>(\n    editStateKey: string,\n    owner: Editor<EType, LAnnotation, Caret>,\n    discard = false\n  ): void {\n    const activeSession = this.#sessions.get(editStateKey);\n    if (activeSession?.owner !== owner) {\n      return;\n    }\n    this.#sessions.delete(editStateKey);\n    if (discard) {\n      return;\n    }\n    const retainedState = toManagedEditState(activeSession.session);\n    if (retainedState != null) {\n      this.#states.set(editStateKey, retainedState as EditState<EType>);\n    }\n  }\n\n  get<LAnnotation>(\n    editStateKey: string\n  ): EditState<EType, LAnnotation> | undefined {\n    const activeSession = this.#sessions.get(editStateKey);\n    if (activeSession != null) {\n      const state = toManagedEditState(\n        activeSession.session as ManagedEditSession<EType, LAnnotation>\n      );\n      if (state == null) {\n        return undefined;\n      }\n      return state;\n    }\n    const state = this.#states.find(editStateKey);\n    return state as EditState<EType, LAnnotation> | undefined;\n  }\n\n  /** Clear dormant state for a key. Omit `parts` to clear everything. */\n  clear(editStateKey: string, parts?: ClearEditStateOptions): boolean {\n    if (this.#sessions.has(editStateKey)) {\n      return false;\n    }\n\n    const state = this.#states.find(editStateKey);\n    if (state == null) {\n      return false;\n    }\n    if (parts == null || parts.document === true) {\n      this.#states.delete(editStateKey);\n    } else {\n      applyClearEditStateOptions(state, parts);\n    }\n    return true;\n  }\n\n  clearAll(): void {\n    this.#states.clear();\n  }\n\n  setCapacity(capacity: number): void {\n    if (!Number.isSafeInteger(capacity) || capacity < 1) {\n      throw new RangeError(\n        'EditStateManager: capacity must be a positive integer'\n      );\n    }\n    while (this.#states.size > capacity) {\n      this.#states.shift();\n    }\n    this.#states.limit = capacity;\n  }\n}\n\n/** Keeps file and diff edit state in independent persistence domains. */\nclass EditStateManagerClass {\n  #files = new EditStateManagerNamespace('file');\n  #diffs = new EditStateManagerNamespace('file-diff');\n\n  /** Mark a keyed session as active and return its initial or stored state. */\n  activate<EType extends EditorType, LAnnotation, Caret>(\n    type: EType,\n    editStateKey: string,\n    owner: Editor<EType, LAnnotation, Caret>,\n    initialState?: ManagedEditSession<EType, LAnnotation>\n  ): ManagedEditSession<EType, LAnnotation> {\n    return (\n      type === 'file'\n        ? this.#files.activate(\n            editStateKey,\n            owner as Editor<'file', LAnnotation, Caret>,\n            initialState as ManagedFileEditSession<LAnnotation> | undefined\n          )\n        : this.#diffs.activate(\n            editStateKey,\n            owner as Editor<'file-diff', LAnnotation, Caret>,\n            initialState as ManagedFileDiffEditSession<LAnnotation> | undefined\n          )\n    ) as ManagedEditSession<EType, LAnnotation>;\n  }\n\n  /**\n   * Stop tracking this file session as active and store its current state,\n   * unless `discard` is true.\n   */\n  releaseFile<LAnnotation, Caret>(\n    editStateKey: string,\n    owner: Editor<'file', LAnnotation, Caret>,\n    discard = false\n  ): void {\n    this.#files.release(editStateKey, owner, discard);\n  }\n\n  /**\n   * Stop tracking this diff session as active and store its current state,\n   * unless `discard` is true.\n   */\n  releaseFileDiff<LAnnotation, Caret>(\n    editStateKey: string,\n    owner: Editor<'file-diff', LAnnotation, Caret>,\n    discard = false\n  ): void {\n    this.#diffs.release(editStateKey, owner, discard);\n  }\n\n  /** Return current state for an active or dormant editing session. */\n  get<EType extends EditorType, LAnnotation>(\n    type: EType,\n    editStateKey: string\n  ): EditState<EType, LAnnotation> | undefined {\n    return (\n      type === 'file'\n        ? this.#files.get<LAnnotation>(editStateKey)\n        : this.#diffs.get<LAnnotation>(editStateKey)\n    ) as EditState<EType, LAnnotation> | undefined;\n  }\n\n  /** Clear a dormant session, returning false when it is active or missing. */\n  clear(\n    type: EditorType,\n    editStateKey: string,\n    parts?: ClearEditStateOptions\n  ): boolean {\n    return type === 'file'\n      ? this.#files.clear(editStateKey, parts)\n      : this.#diffs.clear(editStateKey, parts);\n  }\n\n  /** Clear all dormant sessions without affecting active editors. */\n  clearAll(): void {\n    this.#files.clearAll();\n    this.#diffs.clearAll();\n  }\n\n  setCapacity(capacity: number): void {\n    this.#files.setCapacity(capacity);\n    this.#diffs.setCapacity(capacity);\n  }\n}\n\nexport interface ClearEditStateOptions {\n  document?: boolean;\n  history?: boolean;\n  editor?: boolean;\n  selections?: boolean;\n  view?: boolean;\n}\n\nexport function cloneEditorViewState(state: EditorViewState): EditorViewState {\n  return {\n    selections: state.selections?.map((selection) => ({\n      ...selection,\n      start: { ...selection.start },\n      end: { ...selection.end },\n    })),\n    view: state.view == null ? undefined : { ...state.view },\n  };\n}\n\nexport function toManagedEditState<EType extends EditorType, LAnnotation>(\n  session: ManagedEditSession<EType, LAnnotation>\n): EditState<EType, LAnnotation> | undefined {\n  if (session.document == null || session.fileInfo == null) {\n    return undefined;\n  }\n  if (session.type === 'file') {\n    session.editor ??= {};\n    return session as EditState<EType, LAnnotation>;\n  }\n  if (session.diffSession == null) {\n    return undefined;\n  }\n  session.editor ??= {};\n  return session as EditState<EType, LAnnotation>;\n}\n\nfunction applyClearEditStateOptions(\n  session: ManagedEditSession | undefined,\n  parts: ClearEditStateOptions\n): void {\n  if (session == null) {\n    return;\n  }\n  if (parts.history === true) {\n    session.document?.clearHistory();\n  }\n  if (session.editor != null) {\n    if (parts.editor === true || parts.selections === true) {\n      session.editor.selections = undefined;\n    }\n    if (parts.editor === true || parts.view === true) {\n      session.editor.view = undefined;\n    }\n  }\n}\n\nexport const EditStateManager: EditStateManagerClass =\n  new EditStateManagerClass();\n"],"mappings":"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"}

package/dist/editor/cloneRetainedDiffSessionSnapshot.d.ts

@@ -0,0 +1,7 @@
+import { RetainedDiffSessionSnapshot } from "./types.js";
+
+//#region src/editor/cloneRetainedDiffSessionSnapshot.d.ts
+declare function cloneRetainedDiffSessionSnapshot(snapshot: RetainedDiffSessionSnapshot): RetainedDiffSessionSnapshot;
+//#endregion
+export { cloneRetainedDiffSessionSnapshot };
+//# sourceMappingURL=cloneRetainedDiffSessionSnapshot.d.ts.map

package/dist/editor/cloneRetainedDiffSessionSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneRetainedDiffSessionSnapshot.d.ts","names":[],"sources":["../../src/editor/cloneRetainedDiffSessionSnapshot.ts"],"mappings":";;;iBAGgB,gCAAA,CACd,QAAA,EAAU,2BAAA,GACT,2BAA2B"}

package/dist/editor/cloneRetainedDiffSessionSnapshot.js

@@ -0,0 +1,16 @@
+import { cloneHunks } from "../utils/cloneFileDiffMetadata.js";
+//#region src/editor/cloneRetainedDiffSessionSnapshot.ts
+function cloneRetainedDiffSessionSnapshot(snapshot) {
+	return {
+		...snapshot,
+		oldFile: snapshot.oldFile != null ? {
+			...snapshot.oldFile,
+			lines: [...snapshot.oldFile.lines]
+		} : null,
+		hunks: cloneHunks(snapshot.hunks)
+	};
+}
+//#endregion
+export { cloneRetainedDiffSessionSnapshot };
+
+//# sourceMappingURL=cloneRetainedDiffSessionSnapshot.js.map

package/dist/editor/cloneRetainedDiffSessionSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneRetainedDiffSessionSnapshot.js","names":[],"sources":["../../src/editor/cloneRetainedDiffSessionSnapshot.ts"],"sourcesContent":["import { cloneHunks } from '../utils/cloneFileDiffMetadata';\nimport type { RetainedDiffSessionSnapshot } from './types';\n\nexport function cloneRetainedDiffSessionSnapshot(\n  snapshot: RetainedDiffSessionSnapshot\n): RetainedDiffSessionSnapshot {\n  return {\n    ...snapshot,\n    oldFile:\n      snapshot.oldFile != null\n        ? { ...snapshot.oldFile, lines: [...snapshot.oldFile.lines] }\n        : null,\n    hunks: cloneHunks(snapshot.hunks),\n  };\n}\n"],"mappings":";;AAGA,SAAgB,iCACd,UAC6B;CAC7B,OAAO;EACL,GAAG;EACH,SACE,SAAS,WAAW,OAChB;GAAE,GAAG,SAAS;GAAS,OAAO,CAAC,GAAG,SAAS,QAAQ,KAAK;EAAE,IAC1D;EACN,OAAO,WAAW,SAAS,KAAK;CAClC;AACF"}

package/dist/editor/editPrediction.d.ts

@@ -0,0 +1,76 @@
+import { Position, TextEdit } from "./types.js";
+import { TextDocumentChangeTransaction } from "./textDocumentChangeTransaction.js";
+
+//#region src/editor/editPrediction.d.ts
+interface EditPredictRequest {
+  /** Current file name/path as supplied to the File or FileDiff component. */
+  readonly path: string;
+  /** Document version. */
+  readonly version: number;
+  /** Document end-of-line sequence. */
+  readonly eol: '\n' | '\r\n' | '\r';
+  /** Bounded slice of the file around the cursor (not the whole file). */
+  readonly excerptText: string;
+  /** Zero-based document line where the excerpt starts. */
+  readonly excerptStartLine: number;
+  /** UTF-16 cursor offset relative to `excerptText`. */
+  readonly cursorOffsetInExcerpt: number;
+  /** Half-open UTF-16 range within `excerptText` that may be edited. */
+  readonly editableRange: {
+    readonly start: number;
+    readonly end: number;
+  };
+  /** Chronological, bounded edit history for this document. */
+  readonly editHistory: ReadonlyArray<{
+    /** Edit in unified-diff format. */readonly diff: string; /** Edit source. */
+    readonly source: 'user' | 'prediction';
+  }>;
+}
+interface EditPredictContext {
+  /** Aborted when the document or cursor changes. */
+  readonly signal: AbortSignal;
+}
+interface EditPredictResponse {
+  /** Non-overlapping edits using absolute document positions. */
+  readonly edits: readonly TextEdit[];
+  /** Absolute post-edit cursor position. */
+  readonly newCursor: Position;
+}
+interface EditPredictProvider {
+  /** Predicts the next edit for the given request. */
+  predict: (request: EditPredictRequest, context: EditPredictContext) => Promise<EditPredictResponse>;
+}
+interface EditPredictionHistoryRecord {
+  readonly path: string;
+  readonly hunk: string;
+  readonly start: number;
+  readonly end: number;
+  readonly at: number;
+  readonly source: 'user' | 'prediction';
+  readonly fragment?: EditPredictionHistoryFragment;
+}
+interface EditPredictionDocument {
+  readonly version: number;
+  readonly eol: '\n' | '\r\n' | '\r';
+  readonly lineCount: number;
+  positionAt(offset: number): Position;
+  positionsAt(offsets: readonly number[]): Position[];
+  offsetAt(position: Position): number;
+  getLineText(line: number): string;
+  getLineLength(line: number): number;
+  getTextSlice(start: number, end: number): string;
+  charAt(offset: number): string;
+}
+interface EditPredictionHistoryFragment {
+  readonly baseText: string;
+  readonly currentText: string;
+  readonly currentStart: number;
+  readonly currentEnd: number;
+  readonly startLine: number;
+}
+declare function recordEditPrediction(history: readonly EditPredictionHistoryRecord[], path: string, document: EditPredictionDocument, transaction: TextDocumentChangeTransaction, source: 'user' | 'prediction', at?: number): EditPredictionHistoryRecord[];
+declare function buildEditPredictionRequest(path: string, document: EditPredictionDocument, cursorOffset: number, history: readonly EditPredictionHistoryRecord[], isLineEditable: (line: number) => boolean): EditPredictRequest | undefined;
+declare function matchesEditPredictionPattern(path: string, pattern: string | RegExp): boolean;
+//#endregion
+export { EditPredictContext, EditPredictProvider, EditPredictRequest, EditPredictResponse, EditPredictionHistoryRecord, buildEditPredictionRequest, matchesEditPredictionPattern, recordEditPrediction };
+//# sourceMappingURL=editPrediction.d.ts.map

package/dist/editor/editPrediction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editPrediction.d.ts","names":[],"sources":["../../src/editor/editPrediction.ts"],"mappings":";;;;UAGiB,kBAAA;;WAEN,IAAA;EAFwB;EAAA,SAIxB,OAAA;EAY0B;EAAA,SAV1B,GAAA;EAFA;EAAA,SAIA,WAAA;EAAA;EAAA,SAEA,gBAAA;EAEA;EAAA,SAAA,qBAAA;EAE0B;EAAA,SAA1B,aAAA;IAAA,SAA0B,KAAA;IAAA,SAAwB,GAAA;EAAA;EAMhD;EAAA,SAJF,WAAA,EAAa,aAAa;IAIlB,4CAFN,IAAA,UAMsB;IAAA,SAJtB,MAAA;EAAA;AAAA;AAAA,UAII,kBAAA;EAKmB;EAAA,SAHzB,MAAA,EAAQ,WAAW;AAAA;AAAA,UAGb,mBAAA;EAEU;EAAA,SAAhB,KAAA,WAAgB,QAAA;EAEL;EAAA,SAAX,SAAA,EAAW,QAAQ;AAAA;AAAA,UAGb,mBAAA;EAAmB;EAElC,OAAA,GACE,OAAA,EAAS,kBAAA,EACT,OAAA,EAAS,kBAAA,KACN,OAAA,CAAQ,mBAAA;AAAA;AAAA,UAGE,2BAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;EAAA,SACA,GAAA;EAAA,SACA,EAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,GAAW,6BAA6B;AAAA;AAAA,UAGzC,sBAAA;EAAA,SACC,OAAA;EAAA,SACA,GAAA;EAAA,SACA,SAAA;EACT,UAAA,CAAW,MAAA,WAAiB,QAAA;EAC5B,WAAA,CAAY,OAAA,sBAA6B,QAAA;EACzC,QAAA,CAAS,QAAA,EAAU,QAAA;EACnB,WAAA,CAAY,IAAA;EACZ,aAAA,CAAc,IAAA;EACd,YAAA,CAAa,KAAA,UAAe,GAAA;EAC5B,MAAA,CAAO,MAAA;AAAA;AAAA,UAGC,6BAAA;EAAA,SACC,QAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;AAAA;AAAA,iBAmTK,oBAAA,CACd,OAAA,WAAkB,2BAAA,IAClB,IAAA,UACA,QAAA,EAAU,sBAAA,EACV,WAAA,EAAa,6BAAA,EACb,MAAA,yBACA,EAAA,YACC,2BAAA;AAAA,iBAwLa,0BAAA,CACd,IAAA,UACA,QAAA,EAAU,sBAAA,EACV,YAAA,UACA,OAAA,WAAkB,2BAAA,IAClB,cAAA,GAAiB,IAAA,uBAChB,kBAAA;AAAA,iBAmKa,4BAAA,CACd,IAAA,UACA,OAAA,WAAkB,MAAM"}

package/dist/editor/editPrediction.js

@@ -0,0 +1,365 @@
+//#region src/editor/editPrediction.ts
+const EDITABLE_TOKENS = 350;
+const CONTEXT_TOKENS = 150;
+const MAX_EDITABLE_TOKENS = 512;
+const MAX_CONTEXT_TOKENS = 662;
+const MAX_REQUEST_BYTES = 128 * 1024;
+const MAX_CAPTURE_BYTES = 6144;
+const COALESCE_MS = 1e3;
+const COALESCE_LINES = 8;
+const DIFF_CONTEXT_LINES = 3;
+const CAPTURE_CONTEXT_OPTIONS = [11, DIFF_CONTEXT_LINES];
+const textEncoder = new TextEncoder();
+function lineStarts(text) {
+	const starts = [0];
+	for (let index = 0; index < text.length; index++) {
+		if (text.charCodeAt(index) === 13 && text.charCodeAt(index + 1) === 10) index++;
+		if (text.charCodeAt(index) === 10 || text.charCodeAt(index) === 13) starts.push(index + 1);
+	}
+	return starts;
+}
+function diffLineCount(text, starts) {
+	if (text.length === 0) return 0;
+	return starts.at(-1) === text.length ? starts.length - 1 : starts.length;
+}
+function lineEnd(text, starts, line) {
+	const next = starts[line + 1];
+	return next === void 0 ? text.length : next - (text.charCodeAt(next - 1) === 10 && text.charCodeAt(next - 2) === 13 ? 2 : 1);
+}
+function linesEqual(left, leftStarts, leftLine, right, rightStarts, rightLine) {
+	const leftStart = leftStarts[leftLine];
+	const rightStart = rightStarts[rightLine];
+	const length = lineEnd(left, leftStarts, leftLine) - leftStart;
+	if (length !== lineEnd(right, rightStarts, rightLine) - rightStart) return false;
+	for (let index = 0; index < length; index++) if (left.charCodeAt(leftStart + index) !== right.charCodeAt(rightStart + index)) return false;
+	return true;
+}
+function lineDiffBounds(oldText, oldStarts, newText, newStarts) {
+	const oldLineCount = diffLineCount(oldText, oldStarts);
+	const newLineCount = diffLineCount(newText, newStarts);
+	let prefixLines = 0;
+	while (prefixLines < oldLineCount && prefixLines < newLineCount) {
+		if (!linesEqual(oldText, oldStarts, prefixLines, newText, newStarts, prefixLines)) break;
+		prefixLines++;
+	}
+	let suffixLines = 0;
+	while (suffixLines < oldLineCount - prefixLines && suffixLines < newLineCount - prefixLines) {
+		if (!linesEqual(oldText, oldStarts, oldLineCount - 1 - suffixLines, newText, newStarts, newLineCount - 1 - suffixLines)) break;
+		suffixLines++;
+	}
+	return {
+		oldLineCount,
+		newLineCount,
+		prefixLines,
+		suffixLines
+	};
+}
+function formatEditHunk(path, oldText, newText, lineOffset = 0) {
+	if (oldText === newText) return;
+	const oldStarts = lineStarts(oldText);
+	const newStarts = lineStarts(newText);
+	const bounds = lineDiffBounds(oldText, oldStarts, newText, newStarts);
+	if (bounds.prefixLines === bounds.oldLineCount && bounds.prefixLines === bounds.newLineCount) return;
+	const oldChangedEnd = bounds.oldLineCount - bounds.suffixLines;
+	const newChangedEnd = bounds.newLineCount - bounds.suffixLines;
+	const oldChanged = oldText.slice(oldStarts[bounds.prefixLines] ?? oldText.length, oldStarts[oldChangedEnd] ?? oldText.length);
+	const newChanged = newText.slice(newStarts[bounds.prefixLines] ?? newText.length, newStarts[newChangedEnd] ?? newText.length);
+	if (textEncoder.encode(oldChanged).byteLength > MAX_CAPTURE_BYTES || textEncoder.encode(newChanged).byteLength > MAX_CAPTURE_BYTES) return;
+	const start = Math.max(0, bounds.prefixLines - DIFF_CONTEXT_LINES);
+	const oldEnd = Math.min(bounds.oldLineCount, oldChangedEnd + DIFF_CONTEXT_LINES);
+	const newEnd = Math.min(bounds.newLineCount, newChangedEnd + DIFF_CONTEXT_LINES);
+	const oldCount = oldEnd - start;
+	const newCount = newEnd - start;
+	const line = start + lineOffset;
+	const output = [
+		`--- a/${path}`,
+		`+++ b/${path}`,
+		`@@ -${oldCount === 0 ? line : line + 1},${oldCount} +${newCount === 0 ? line : line + 1},${newCount} @@`
+	];
+	for (let line = start; line < bounds.prefixLines; line++) output.push(` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	for (let line = bounds.prefixLines; line < oldChangedEnd; line++) output.push(`-${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	for (let line = bounds.prefixLines; line < newChangedEnd; line++) output.push(`+${newText.slice(newStarts[line], lineEnd(newText, newStarts, line))}`);
+	for (let line = oldChangedEnd; line < oldEnd; line++) output.push(` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	const hunk = output.join("\n");
+	return textEncoder.encode(hunk).byteLength <= MAX_CAPTURE_BYTES ? {
+		hunk,
+		bounds
+	} : void 0;
+}
+function applyEditsToSlice(text, sliceStart, edits) {
+	const chunks = [];
+	let offset = 0;
+	for (const edit of edits) {
+		const start = edit.start - sliceStart;
+		const end = edit.end - sliceStart;
+		if (start < offset || end < start || end > text.length) return;
+		chunks.push(text.slice(offset, start), edit.text);
+		offset = end;
+	}
+	chunks.push(text.slice(offset));
+	return chunks.join("");
+}
+function captureEditPredictionTransaction(document, transaction) {
+	const inverseEdits = transaction.inverseEdits;
+	if (inverseEdits.length === 0) return;
+	let changedStart = inverseEdits[0].start;
+	let changedEnd = inverseEdits[0].end;
+	for (let index = 1; index < inverseEdits.length; index++) {
+		changedStart = Math.min(changedStart, inverseEdits[index].start);
+		changedEnd = Math.max(changedEnd, inverseEdits[index].end);
+	}
+	const [startPosition, endPosition] = document.positionsAt([changedStart, changedEnd]);
+	for (const contextLines of CAPTURE_CONTEXT_OPTIONS) {
+		const startLine = Math.max(0, startPosition.line - contextLines);
+		const endLine = Math.min(document.lineCount - 1, endPosition.line + contextLines);
+		const afterStart = document.offsetAt({
+			line: startLine,
+			character: 0
+		});
+		const afterEnd = endLine + 1 < document.lineCount ? document.offsetAt({
+			line: endLine + 1,
+			character: 0
+		}) : document.offsetAt({
+			line: endLine,
+			character: document.getLineLength(endLine)
+		});
+		if (afterEnd - afterStart > MAX_CAPTURE_BYTES) continue;
+		const afterText = document.getTextSlice(afterStart, afterEnd);
+		if (textEncoder.encode(afterText).byteLength > MAX_CAPTURE_BYTES) continue;
+		const beforeText = applyEditsToSlice(afterText, afterStart, inverseEdits);
+		if (beforeText === void 0 || beforeText.length > MAX_CAPTURE_BYTES || textEncoder.encode(beforeText).byteLength > MAX_CAPTURE_BYTES) continue;
+		return {
+			beforeText,
+			afterText,
+			startOffset: afterStart,
+			startLine,
+			bounds: lineDiffBounds(beforeText, lineStarts(beforeText), afterText, lineStarts(afterText))
+		};
+	}
+}
+function recordEditPrediction(history, path, document, transaction, source, at = Date.now()) {
+	const kept = history.slice(-10);
+	const fragment = captureEditPredictionTransaction(document, transaction);
+	if (fragment === void 0) {
+		const previous = kept.at(-1);
+		if (previous?.fragment !== void 0) kept[kept.length - 1] = {
+			...previous,
+			fragment: void 0
+		};
+		return kept;
+	}
+	if (fragment.beforeText === fragment.afterText) return kept;
+	const changedStartLine = fragment.startLine + fragment.bounds.prefixLines;
+	const beforeChangedEndLine = fragment.startLine + fragment.bounds.oldLineCount - fragment.bounds.suffixLines;
+	const last = kept.at(-1);
+	const gap = last !== void 0 && changedStartLine > last.end ? changedStartLine - last.end : last !== void 0 && last.start > beforeChangedEndLine ? last.start - beforeChangedEndLine : 0;
+	if (last !== void 0 && last.fragment !== void 0 && last.path === path && last.source === source && at - last.at < COALESCE_MS && gap <= COALESCE_LINES) {
+		const previous = last.fragment;
+		const beforeEnd = fragment.startOffset + fragment.beforeText.length;
+		const overlapStart = Math.max(previous.currentStart, fragment.startOffset);
+		const overlapEnd = Math.min(previous.currentEnd, beforeEnd);
+		if (overlapStart <= overlapEnd && previous.currentText.slice(overlapStart - previous.currentStart, overlapEnd - previous.currentStart) === fragment.beforeText.slice(overlapStart - fragment.startOffset, overlapEnd - fragment.startOffset)) {
+			const unionStart = Math.min(previous.currentStart, fragment.startOffset);
+			const currentText = previous.currentStart <= fragment.startOffset ? previous.currentText + fragment.beforeText.slice(Math.max(0, previous.currentEnd - fragment.startOffset)) : fragment.beforeText + previous.currentText.slice(Math.max(0, beforeEnd - previous.currentStart));
+			const prefix = currentText.slice(0, previous.currentStart - unionStart);
+			const suffix = currentText.slice(previous.currentEnd - unionStart);
+			const baseText = prefix + previous.baseText + suffix;
+			const nextText = applyEditsToSlice(currentText, unionStart, transaction.appliedEdits);
+			const startLine = previous.currentStart <= fragment.startOffset ? previous.startLine : fragment.startLine;
+			if (nextText !== void 0 && baseText.length <= MAX_CAPTURE_BYTES && nextText.length <= MAX_CAPTURE_BYTES && textEncoder.encode(baseText).byteLength <= MAX_CAPTURE_BYTES && textEncoder.encode(nextText).byteLength <= MAX_CAPTURE_BYTES) {
+				if (baseText === nextText) {
+					kept.pop();
+					return kept;
+				}
+				const formatted = formatEditHunk(path, baseText, nextText, startLine);
+				if (formatted !== void 0) {
+					kept[kept.length - 1] = {
+						path,
+						hunk: formatted.hunk,
+						start: startLine + formatted.bounds.prefixLines,
+						end: startLine + formatted.bounds.newLineCount - formatted.bounds.suffixLines,
+						at,
+						source,
+						fragment: {
+							baseText,
+							currentText: nextText,
+							currentStart: unionStart,
+							currentEnd: unionStart + nextText.length,
+							startLine
+						}
+					};
+					return kept;
+				}
+			}
+		}
+	}
+	const previous = kept.at(-1);
+	if (previous?.fragment !== void 0) kept[kept.length - 1] = {
+		...previous,
+		fragment: void 0
+	};
+	const formatted = formatEditHunk(path, fragment.beforeText, fragment.afterText, fragment.startLine);
+	if (formatted === void 0) return kept;
+	kept.push({
+		path,
+		hunk: formatted.hunk,
+		start: changedStartLine,
+		end: fragment.startLine + fragment.bounds.newLineCount - fragment.bounds.suffixLines,
+		at,
+		source,
+		fragment: {
+			baseText: fragment.beforeText,
+			currentText: fragment.afterText,
+			currentStart: fragment.startOffset,
+			currentEnd: fragment.startOffset + fragment.afterText.length,
+			startLine: fragment.startLine
+		}
+	});
+	return kept.slice(-10);
+}
+function expandLinewise(lineCount, costForLine, canExpandTo, first, last, remaining) {
+	while (remaining > 0 && (first > 0 || last < lineCount - 1)) {
+		let expanded = false;
+		if (first > 0 && canExpandTo(first - 1)) {
+			const cost = costForLine(first - 1);
+			if (cost <= remaining) {
+				first--;
+				remaining -= cost;
+				expanded = true;
+			}
+		}
+		if (last < lineCount - 1 && canExpandTo(last + 1)) {
+			const cost = costForLine(last + 1);
+			if (cost <= remaining) {
+				last++;
+				remaining -= cost;
+				expanded = true;
+			}
+		}
+		if (!expanded) break;
+	}
+	return {
+		first,
+		last
+	};
+}
+function buildEditPredictionRequest(path, document, cursorOffset, history, isLineEditable) {
+	if (document.lineCount <= 0) return;
+	const lastLine = document.lineCount - 1;
+	const documentLength = document.offsetAt({
+		line: lastLine,
+		character: document.getLineLength(lastLine)
+	});
+	let cursor = Math.max(0, Math.min(Number.isFinite(cursorOffset) ? Math.trunc(cursorOffset) : 0, documentLength));
+	const previous = document.charAt(cursor - 1).charCodeAt(0);
+	const next = document.charAt(cursor).charCodeAt(0);
+	if (cursor > 0 && cursor < documentLength && (previous === 13 && next === 10 || previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343)) cursor--;
+	const cursorLine = document.positionAt(cursor).line;
+	const editableLines = /* @__PURE__ */ new Map();
+	const canEdit = (line) => {
+		if (line < 0 || line >= document.lineCount) return false;
+		let editable = editableLines.get(line);
+		if (editable == null) {
+			editable = isLineEditable(line);
+			editableLines.set(line, editable);
+		}
+		return editable;
+	};
+	if (!canEdit(cursorLine)) return;
+	const tokenCosts = /* @__PURE__ */ new Map();
+	const costForLine = (line) => {
+		const cached = tokenCosts.get(line);
+		if (cached !== void 0) return cached;
+		const lineLength = document.getLineLength(line);
+		if (Math.floor(lineLength / 3) > MAX_CONTEXT_TOKENS) {
+			const cost = 663;
+			tokenCosts.set(line, cost);
+			return cost;
+		}
+		const cost = Math.max(1, Math.floor(textEncoder.encode(document.getLineText(line)).byteLength / 3));
+		tokenCosts.set(line, cost);
+		return cost;
+	};
+	let editableFirst = cursorLine;
+	let editableLast = cursorLine;
+	const initialBudget = Math.floor(EDITABLE_TOKENS * 3 / 4);
+	let remaining = Math.max(0, initialBudget - costForLine(cursorLine));
+	while (remaining > 0 && (canEdit(editableFirst - 1) || canEdit(editableLast + 1))) {
+		if (canEdit(editableLast + 1)) {
+			const cost = costForLine(editableLast + 1);
+			if (cost > remaining) break;
+			editableLast++;
+			remaining -= cost;
+		}
+		if (canEdit(editableFirst - 1) && remaining > 0) {
+			const cost = costForLine(editableFirst - 1);
+			if (cost > remaining) break;
+			editableFirst--;
+			remaining -= cost;
+		}
+	}
+	remaining += EDITABLE_TOKENS - initialBudget;
+	({first: editableFirst, last: editableLast} = expandLinewise(document.lineCount, costForLine, canEdit, editableFirst, editableLast, remaining));
+	let contextFirst = editableFirst;
+	let contextLast = editableLast;
+	({first: contextFirst, last: contextLast} = expandLinewise(document.lineCount, costForLine, () => true, contextFirst, contextLast, CONTEXT_TOKENS));
+	let editableTokens = 0;
+	for (let line = editableFirst; line <= editableLast; line++) editableTokens += costForLine(line);
+	let contextTokens = 0;
+	for (let line = contextFirst; line <= contextLast; line++) contextTokens += costForLine(line);
+	if (editableTokens > MAX_EDITABLE_TOKENS || contextTokens > MAX_CONTEXT_TOKENS) return;
+	const contextStart = document.offsetAt({
+		line: contextFirst,
+		character: 0
+	});
+	const contextEnd = document.offsetAt({
+		line: contextLast,
+		character: document.getLineLength(contextLast)
+	});
+	const excerptText = document.getTextSlice(contextStart, contextEnd);
+	const request = {
+		path,
+		version: document.version,
+		eol: document.eol,
+		excerptText,
+		excerptStartLine: contextFirst,
+		cursorOffsetInExcerpt: cursor - contextStart,
+		editableRange: {
+			start: document.offsetAt({
+				line: editableFirst,
+				character: 0
+			}) - contextStart,
+			end: document.offsetAt({
+				line: editableLast,
+				character: document.getLineLength(editableLast)
+			}) - contextStart
+		},
+		editHistory: history.slice(-10).map(({ hunk, source }) => ({
+			diff: hunk,
+			source
+		}))
+	};
+	return textEncoder.encode(JSON.stringify(request)).byteLength <= MAX_REQUEST_BYTES ? request : void 0;
+}
+function matchesEditPredictionPattern(path, pattern) {
+	if (typeof pattern !== "string") return new RegExp(pattern.source, pattern.flags).test(path);
+	pattern = pattern.replaceAll("\\", "/");
+	let source = "^";
+	for (let index = 0; index < pattern.length; index++) {
+		const character = pattern[index];
+		if (character === "*") if (pattern[index + 1] === "*") {
+			index++;
+			if (pattern[index + 1] === "/") {
+				index++;
+				source += "(?:.*/)?";
+			} else source += ".*";
+		} else source += "[^/]*";
+		else if (character === "?") source += "[^/]";
+		else source += /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+	}
+	return new RegExp(`${source}$`).test(path);
+}
+//#endregion
+export { buildEditPredictionRequest, matchesEditPredictionPattern, recordEditPrediction };
+
+//# sourceMappingURL=editPrediction.js.map