@luan.sh/pi-custom-editor 0.3.2

package/node_modules/@pierre/diffs/dist/editor/stateStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateStorage.js","names":["#states","#database"],"sources":["../../src/editor/stateStorage.ts"],"sourcesContent":["import type { EditorState } from '../types';\n\nexport interface IStateStorage {\n  /** Read the editor state stored for a file cache key. */\n  get(\n    cacheKey: string\n  ): EditorState | undefined | Promise<EditorState | undefined>;\n  /** Store the editor state for a file cache key. */\n  set(cacheKey: string, state: EditorState): void | Promise<void>;\n}\n\nexport type PersistStateStorage = 'inMemory' | 'indexedDB' | IStateStorage;\n\nexport function cloneEditorState(state: EditorState): EditorState {\n  return {\n    selections: state.selections?.map((selection) => ({\n      start: { ...selection.start },\n      end: { ...selection.end },\n      direction: selection.direction,\n    })),\n    view: state.view === undefined ? undefined : { ...state.view },\n  };\n}\n\nexport function createStateStorage(\n  storage: PersistStateStorage\n): IStateStorage {\n  return typeof storage === 'object'\n    ? storage\n    : storage === 'indexedDB'\n      ? new IndexedDBStateStorage()\n      : new InMemoryStateStorage();\n}\n\nclass InMemoryStateStorage implements IStateStorage {\n  #states = new Map<string, EditorState>();\n\n  get(cacheKey: string): EditorState | undefined {\n    const state = this.#states.get(cacheKey);\n    return state === undefined ? undefined : cloneEditorState(state);\n  }\n\n  set(cacheKey: string, state: EditorState): void {\n    this.#states.set(cacheKey, cloneEditorState(state));\n  }\n}\n\nconst DATABASE_NAME = 'pierre-diffs-editor-state';\nconst DATABASE_VERSION = 1;\nconst STORE_NAME = 'states';\n\nclass IndexedDBStateStorage implements IStateStorage {\n  #database = openDatabase();\n\n  async get(cacheKey: string): Promise<EditorState | undefined> {\n    const database = await this.#database;\n    if (database === undefined) {\n      return undefined;\n    }\n    const state = await requestToPromise<EditorState | undefined>(\n      database\n        .transaction(STORE_NAME, 'readonly')\n        .objectStore(STORE_NAME)\n        .get(cacheKey)\n    );\n    return state === undefined ? undefined : cloneEditorState(state);\n  }\n\n  async set(cacheKey: string, state: EditorState): Promise<void> {\n    const database = await this.#database;\n    if (database === undefined) {\n      return;\n    }\n    await requestToPromise(\n      database\n        .transaction(STORE_NAME, 'readwrite')\n        .objectStore(STORE_NAME)\n        .put(cloneEditorState(state), cacheKey)\n    );\n  }\n}\n\nfunction openDatabase(): Promise<IDBDatabase | undefined> {\n  try {\n    const factory = globalThis.indexedDB;\n    if (factory === undefined) {\n      return Promise.resolve(undefined);\n    }\n\n    const request = factory.open(DATABASE_NAME, DATABASE_VERSION);\n    request.onupgradeneeded = () => {\n      const database = request.result;\n      if (!database.objectStoreNames.contains(STORE_NAME)) {\n        database.createObjectStore(STORE_NAME);\n      }\n    };\n    return requestToPromise(request);\n  } catch {\n    return Promise.resolve(undefined);\n  }\n}\n\nfunction requestToPromise<T>(request: IDBRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error);\n  });\n}\n"],"mappings":";AAaA,SAAgB,iBAAiB,OAAiC;CAChE,OAAO;EACL,YAAY,MAAM,YAAY,KAAK,eAAe;GAChD,OAAO,EAAE,GAAG,UAAU,MAAM;GAC5B,KAAK,EAAE,GAAG,UAAU,IAAI;GACxB,WAAW,UAAU;EACvB,EAAE;EACF,MAAM,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,EAAE,GAAG,MAAM,KAAK;CAC/D;AACF;AAEA,SAAgB,mBACd,SACe;CACf,OAAO,OAAO,YAAY,WACtB,UACA,YAAY,cACV,IAAI,sBAAsB,IAC1B,IAAI,qBAAqB;AACjC;AAEA,IAAM,uBAAN,MAAoD;CAClD,0BAAU,IAAI,IAAyB;CAEvC,IAAI,UAA2C;EAC7C,MAAM,QAAQ,KAAKA,QAAQ,IAAI,QAAQ;EACvC,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY,iBAAiB,KAAK;CACjE;CAEA,IAAI,UAAkB,OAA0B;EAC9C,KAAKA,QAAQ,IAAI,UAAU,iBAAiB,KAAK,CAAC;CACpD;AACF;AAEA,MAAM,gBAAgB;AACtB,MAAM,mBAAmB;AACzB,MAAM,aAAa;AAEnB,IAAM,wBAAN,MAAqD;CACnD,YAAY,aAAa;CAEzB,MAAM,IAAI,UAAoD;EAC5D,MAAM,WAAW,MAAM,KAAKC;EAC5B,IAAI,aAAa,KAAA,GACf;EAEF,MAAM,QAAQ,MAAM,iBAClB,SACG,YAAY,YAAY,UAAU,CAAC,CACnC,YAAY,UAAU,CAAC,CACvB,IAAI,QAAQ,CACjB;EACA,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY,iBAAiB,KAAK;CACjE;CAEA,MAAM,IAAI,UAAkB,OAAmC;EAC7D,MAAM,WAAW,MAAM,KAAKA;EAC5B,IAAI,aAAa,KAAA,GACf;EAEF,MAAM,iBACJ,SACG,YAAY,YAAY,WAAW,CAAC,CACpC,YAAY,UAAU,CAAC,CACvB,IAAI,iBAAiB,KAAK,GAAG,QAAQ,CAC1C;CACF;AACF;AAEA,SAAS,eAAiD;CACxD,IAAI;EACF,MAAM,UAAU,WAAW;EAC3B,IAAI,YAAY,KAAA,GACd,OAAO,QAAQ,QAAQ,KAAA,CAAS;EAGlC,MAAM,UAAU,QAAQ,KAAK,eAAe,gBAAgB;EAC5D,QAAQ,wBAAwB;GAC9B,MAAM,WAAW,QAAQ;GACzB,IAAI,CAAC,SAAS,iBAAiB,SAAS,UAAU,GAChD,SAAS,kBAAkB,UAAU;EAEzC;EACA,OAAO,iBAAiB,OAAO;CACjC,QAAQ;EACN,OAAO,QAAQ,QAAQ,KAAA,CAAS;CAClC;AACF;AAEA,SAAS,iBAAoB,SAAoC;CAC/D,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,QAAQ,kBAAkB,QAAQ,QAAQ,MAAM;EAChD,QAAQ,gBAAgB,OAAO,QAAQ,KAAK;CAC9C,CAAC;AACH"}

package/node_modules/@pierre/diffs/dist/editor/textDocument.d.ts

@@ -0,0 +1,67 @@
+import { DiffLineAnnotation, EditorChange, EditorSelection, Position, Range, ResolvedTextEdit, TextEdit } from "../types.js";
+import { EditStack } from "./editStack.js";
+import { SearchParams } from "./searchPanel.js";
+
+//#region src/editor/textDocument.d.ts
+interface TextDocumentChange {
+  /** The edits that were applied to the text document. */
+  readonly changes: EditorChange[];
+  /** First line whose rendered content or tokenizer state may have changed. */
+  readonly startLine: number;
+  /** Character on the first changed line where the edit began. */
+  readonly startCharacter: number;
+  /** Character on the original last changed line where the edit ended. */
+  readonly endCharacter: number;
+  /** Last line whose rendered content may have changed after the edit. */
+  readonly endLine: number;
+  /** Whether the original edit range ended at the previous document EOF. */
+  readonly endedAtDocumentEnd: boolean;
+  /** Line count before the edit was applied. */
+  readonly previousLineCount: number;
+  /** Line count after the edit was applied. */
+  readonly lineCount: number;
+  /** Difference between the old and new line counts. */
+  readonly lineDelta: number;
+  /** Exact rendered line ranges touched by each edit after the edit was applied. */
+  readonly changedLineRanges: readonly [startLine: number, endLine: number][];
+  /** Per-edit rendered line ranges before adjacent ranges are coalesced. */
+  readonly changedLineChanges?: readonly [startLine: number, endLine: number, lineDelta: number, startCharacter?: number, endCharacter?: number, endedAtDocumentEnd?: boolean][];
+}
+type TextDocumentHistoryResult<LAnnotation> = [change: TextDocumentChange, selections?: EditorSelection[], lineAnnotations?: DiffLineAnnotation<LAnnotation>[], selectionEdits?: ResolvedTextEdit[]];
+/**
+ * A vscode-languageserver-textdocument compatible text document.
+ */
+declare class TextDocument<LAnnotation> {
+  #private;
+  constructor(uri: string, text: string, languageId?: string, version?: number, editStack?: EditStack<LAnnotation>);
+  get uri(): string;
+  get languageId(): string;
+  get version(): number;
+  get lineCount(): number;
+  get eol(): string;
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  positionAt(offset: number): Position;
+  positionsAt(offsets: readonly number[]): Position[];
+  offsetAt(position: Position): number;
+  getText(range?: Range): string;
+  getLineText(line: number, includeLineBreak?: boolean): string;
+  normalizeEol(text: string): string;
+  getLineLength(line: number, includeLineBreak?: boolean): number;
+  charAt(offset: number): string;
+  charAt(position: Position): string;
+  getTextSlice(start: number, end: number): string;
+  findNextNonOverlappingSubstring(needle: string, occupied: readonly [start: number, end: number][]): number | undefined;
+  search(searchParams: SearchParams): [start: number, end: number][];
+  applyEdits(edits: TextEdit[], updateHistory?: boolean, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], undoBoundary?: boolean): TextDocumentChange | undefined;
+  resolveEdits(edits: readonly TextEdit[]): ResolvedTextEdit[];
+  applyResolvedEdits(edits: ResolvedTextEdit[], updateHistory?: boolean, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], undoBoundary?: boolean): TextDocumentChange | undefined;
+  setLastUndoSelectionsAfter(selections: EditorSelection[]): void;
+  setLastUndoLineAnnotations(lineAnnotationsBefore: DiffLineAnnotation<LAnnotation>[], lineAnnotationsAfter: DiffLineAnnotation<LAnnotation>[]): void;
+  undo(): TextDocumentHistoryResult<LAnnotation> | undefined;
+  redo(): TextDocumentHistoryResult<LAnnotation> | undefined;
+  normalizePosition(position: Position): Position;
+}
+//#endregion
+export { type Position, type Range, TextDocument, TextDocumentChange, type TextEdit };
+//# sourceMappingURL=textDocument.d.ts.map

package/node_modules/@pierre/diffs/dist/editor/textDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textDocument.d.ts","names":[],"sources":["../../src/editor/textDocument.ts"],"mappings":";;;;;UAqBiB,kBAAA;EAAA;EAAA,SAEN,OAAA,EAAS,YAAY;;WAErB,SAAA;EAFA;EAAA,SAIA,cAAA;EAFA;EAAA,SAIA,YAAA;EAAA;EAAA,SAEA,OAAA;EAEA;EAAA,SAAA,kBAAA;EAIA;EAAA,SAFA,iBAAA;EAMA;EAAA,SAJA,SAAA;EAIgD;EAAA,SAFhD,SAAA;EAKP;EAAA,SAHO,iBAAA,YAA6B,SAAA,UAAmB,OAAA;EAKvD;EAAA,SAHO,kBAAA,aACP,SAAA,UACA,OAAA,UACA,SAAA,UACA,cAAA,WACA,YAAA,WACA,kBAAA;AAAA;AAAA,KAMC,yBAAA,iBACH,MAAA,EAAQ,kBAAA,EACR,UAAA,GAAa,eAAA,IACb,eAAA,GAAkB,kBAAA,CAAmB,WAAA,KACrC,cAAA,GAAiB,gBAAA;;;;cAMN,YAAA;EAAA;EAQX,WAAA,CACE,GAAA,UACA,IAAA,UACA,UAAA,WACA,OAAA,WACA,SAAA,GAAW,SAAA,CAAU,WAAA;EAAA,IAsBnB,GAAA;EAAA,IAIA,UAAA;EAAA,IAIA,OAAA;EAAA,IAIA,SAAA;EAAA,IAIA,GAAA;EAAA,IAIA,OAAA;EAAA,IAIA,OAAA;EAIJ,UAAA,CAAW,MAAA,WAAiB,QAAA;EAI5B,WAAA,CAAY,OAAA,sBAA6B,QAAA;EAQzC,QAAA,CAAS,QAAA,EAAU,QAAA;EAInB,OAAA,CAAQ,KAAA,GAAQ,KAAA;EAgBhB,WAAA,CAAY,IAAA,UAAc,gBAAA;EAO1B,YAAA,CAAa,IAAA;EAIb,aAAA,CAAc,IAAA,UAAc,gBAAA;EAI5B,MAAA,CAAO,MAAA;EACP,MAAA,CAAO,QAAA,EAAU,QAAA;EAQjB,YAAA,CAAa,KAAA,UAAe,GAAA;EAI5B,+BAAA,CACE,MAAA,UACA,QAAA,YAAoB,KAAA,UAAe,GAAA;EAKrC,MAAA,CAAO,YAAA,EAAc,YAAA,IAAgB,KAAA,UAAe,GAAA;EAIpD,UAAA,CACE,KAAA,EAAO,QAAA,IACP,aAAA,YACA,gBAAA,GAAmB,eAAA,IACnB,eAAA,GAAkB,eAAA,IAClB,YAAA,aACC,kBAAA;EAgBH,YAAA,CAAa,KAAA,WAAgB,QAAA,KAAa,gBAAA;EAI1C,kBAAA,CACE,KAAA,EAAO,gBAAA,IACP,aAAA,YACA,gBAAA,GAAmB,eAAA,IACnB,eAAA,GAAkB,eAAA,IAClB,YAAA,aACC,kBAAA;EA2DH,0BAAA,CAA2B,UAAA,EAAY,eAAA;EAIvC,0BAAA,CACE,qBAAA,EAAuB,kBAAA,CAAmB,WAAA,KAC1C,oBAAA,EAAsB,kBAAA,CAAmB,WAAA;EAQ3C,IAAA,IAAQ,yBAAA,CAA0B,WAAA;EAqBlC,IAAA,IAAQ,yBAAA,CAA0B,WAAA;EAqBlC,iBAAA,CAAkB,QAAA,EAAU,QAAA,GAAW,QAAA;AAAA"}

package/node_modules/@pierre/diffs/dist/editor/textDocument.js

@@ -0,0 +1,278 @@
+import { countLineBreaks } from "../utils/computeFileOffsets.js";
+import { EditStack, coalesceEditStackEntries, createEditStackEntry, shouldCoalesceEditStackEntry } from "./editStack.js";
+import { PieceTable } from "./pieceTable.js";
+//#region src/editor/textDocument.ts
+/**
+* A vscode-languageserver-textdocument compatible text document.
+*/
+var TextDocument = class TextDocument {
+	#uri;
+	#languageId;
+	#version;
+	#pieceTable;
+	#editStack;
+	#eol;
+	constructor(uri, text, languageId = "text", version = 0, editStack = new EditStack()) {
+		this.#uri = new URL(uri, "file://").toString();
+		this.#languageId = languageId;
+		this.#version = version;
+		this.#pieceTable = new PieceTable(text);
+		this.#editStack = editStack;
+		const firstLineBreak = this.#pieceTable.getLineText(0, true);
+		if (firstLineBreak.endsWith("\r\n")) this.#eol = "\r\n";
+		else if (firstLineBreak.endsWith("\r")) this.#eol = "\r";
+		else this.#eol = "\n";
+	}
+	get uri() {
+		return this.#uri;
+	}
+	get languageId() {
+		return this.#languageId;
+	}
+	get version() {
+		return this.#version;
+	}
+	get lineCount() {
+		return this.#pieceTable.lineCount;
+	}
+	get eol() {
+		return this.#eol;
+	}
+	get canUndo() {
+		return this.#editStack.canUndo;
+	}
+	get canRedo() {
+		return this.#editStack.canRedo;
+	}
+	positionAt(offset) {
+		return this.normalizePosition(this.#pieceTable.positionAt(offset));
+	}
+	positionsAt(offsets) {
+		const positions = this.#pieceTable.positionsAt(offsets);
+		for (let i = 0; i < positions.length; i++) positions[i] = this.normalizePosition(positions[i]);
+		return positions;
+	}
+	offsetAt(position) {
+		return this.#pieceTable.offsetAt(this.normalizePosition(position));
+	}
+	getText(range) {
+		if (range === void 0) return this.#pieceTable.getText();
+		return this.#pieceTable.getText({
+			start: this.normalizePosition(range.start),
+			end: this.normalizePosition(range.end)
+		});
+	}
+	getLineText(line, includeLineBreak) {
+		return this.#pieceTable.getLineText(line, includeLineBreak);
+	}
+	normalizeEol(text) {
+		return text.replace(/\r\n|\r|\n/g, this.eol);
+	}
+	getLineLength(line, includeLineBreak) {
+		return this.#pieceTable.getLineLength(line, includeLineBreak);
+	}
+	charAt(positionOrOffset) {
+		if (typeof positionOrOffset === "number") return this.#pieceTable.charAt(positionOrOffset);
+		return this.#pieceTable.charAt(this.offsetAt(positionOrOffset));
+	}
+	getTextSlice(start, end) {
+		return this.#pieceTable.getTextSlice(start, end);
+	}
+	findNextNonOverlappingSubstring(needle, occupied) {
+		return this.#pieceTable.findNextNonOverlappingSubstring(needle, occupied);
+	}
+	search(searchParams) {
+		return this.#pieceTable.search(searchParams);
+	}
+	applyEdits(edits, updateHistory = true, selectionsBefore, selectionsAfter, undoBoundary = false) {
+		if (edits.length === 0) return;
+		return this.#applyResolvedEdits(this.#sortAndValidateResolvedEdits(this.resolveEdits(edits)), updateHistory, selectionsBefore, selectionsAfter, undoBoundary);
+	}
+	resolveEdits(edits) {
+		return edits.map((edit) => this.#resolveEdit(edit));
+	}
+	applyResolvedEdits(edits, updateHistory = true, selectionsBefore, selectionsAfter, undoBoundary = false) {
+		if (edits.length === 0) return;
+		return this.#applyResolvedEdits(this.#sortAndValidateResolvedEdits(edits.map((edit) => this.#normalizeResolvedEdit(edit))), updateHistory, selectionsBefore, selectionsAfter, undoBoundary);
+	}
+	#applyResolvedEdits(resolvedEdits, updateHistory, selectionsBefore, selectionsAfter, undoBoundary) {
+		const entry = createEditStackEntry(this, resolvedEdits, this.#version, this.#version + 1, updateHistory ? selectionsBefore : void 0, updateHistory ? selectionsAfter : void 0);
+		if (updateHistory && undoBoundary) entry.undoBoundary = true;
+		const previousEntry = this.#editStack.peekUndoForCoalescing();
+		const change = this.#applyResolvedEditsToBuffer(resolvedEdits);
+		this.#version++;
+		if (change.lineDelta === 0 && shouldCoalesceEditStackEntry(previousEntry, entry)) this.#editStack.replaceLastUndo(coalesceEditStackEntries(previousEntry, entry));
+		else this.#editStack.push(entry);
+		return change;
+	}
+	setLastUndoSelectionsAfter(selections) {
+		this.#editStack.setLastUndoSelectionsAfter(selections);
+	}
+	setLastUndoLineAnnotations(lineAnnotationsBefore, lineAnnotationsAfter) {
+		this.#editStack.setLastUndoLineAnnotations(lineAnnotationsBefore, lineAnnotationsAfter);
+	}
+	undo() {
+		const entry = this.#editStack.popUndoToRedo();
+		if (entry === void 0) return;
+		const change = this.#applyResolvedEditsToBuffer(entry.inverseEdits);
+		if (change === void 0) return;
+		this.#version = entry.versionBefore;
+		const selections = entry.selectionsBefore?.slice();
+		return [
+			change,
+			selections,
+			entry.lineAnnotationsBefore?.slice(),
+			selections === void 0 ? entry.inverseEdits.map((edit) => ({ ...edit })) : void 0
+		];
+	}
+	redo() {
+		const entry = this.#editStack.popRedoToUndo();
+		if (entry === void 0) return;
+		const change = this.#applyResolvedEditsToBuffer(entry.forwardEdits);
+		if (change === void 0) return;
+		this.#version = entry.versionAfter;
+		const selections = entry.selectionsAfter?.slice();
+		return [
+			change,
+			selections,
+			entry.lineAnnotationsAfter?.slice(),
+			selections === void 0 ? entry.forwardEdits.map((edit) => ({ ...edit })) : void 0
+		];
+	}
+	normalizePosition(position) {
+		const line = TextDocument.#clampIndex(position.line, this.lineCount - 1);
+		return {
+			line,
+			character: TextDocument.#clampIndex(position.character, this.getLineLength(line))
+		};
+	}
+	static #clampIndex(value, max) {
+		if (Number.isNaN(value)) return 0;
+		return Math.max(0, Math.min(Math.floor(value), max));
+	}
+	#resolveEdit(edit) {
+		let start = this.offsetAt(edit.range.start);
+		let end = this.offsetAt(edit.range.end);
+		if (start > end) {
+			const t = start;
+			start = end;
+			end = t;
+		}
+		return this.#normalizeResolvedEdit({
+			start,
+			end,
+			text: edit.newText
+		});
+	}
+	#normalizeResolvedEdit(edit) {
+		let { start, end } = edit;
+		const isInsertion = start === end;
+		if (this.#isInsideSurrogatePair(start)) start--;
+		if (isInsertion) end = start;
+		else if (this.#isInsideSurrogatePair(end)) end++;
+		return {
+			start,
+			end,
+			text: edit.text
+		};
+	}
+	#isInsideSurrogatePair(offset) {
+		const previous = this.#pieceTable.charAt(offset - 1).charCodeAt(0);
+		const next = this.#pieceTable.charAt(offset).charCodeAt(0);
+		return previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343;
+	}
+	#sortAndValidateResolvedEdits(edits) {
+		const sortedEdits = [...edits].sort((a, b) => {
+			const startDelta = a.start - b.start;
+			return startDelta === 0 ? a.end - b.end : startDelta;
+		});
+		for (let i = 0; i < sortedEdits.length - 1; i++) if (sortedEdits[i].end > sortedEdits[i + 1].start) throw new Error("Overlapping text edits are not supported");
+		return sortedEdits;
+	}
+	#applyResolvedEditsToBuffer(edits) {
+		const previousLineCount = this.#pieceTable.lineCount;
+		const editPositions = this.positionsAt(edits.flatMap((edit) => [edit.start, edit.end]));
+		const changedLineRange = this.#computeChangedLineRange(edits, editPositions);
+		const startPosition = editPositions[0];
+		const endPosition = editPositions[editPositions.length - 1];
+		const endedAtDocumentEnd = endPosition.line === previousLineCount - 1 && endPosition.character === this.#pieceTable.getLineLength(endPosition.line);
+		this.#pieceTable.applyEdits(edits);
+		const lineCount = this.#pieceTable.lineCount;
+		return {
+			changes: edits.map((edit, index) => ({
+				...edit,
+				range: {
+					start: editPositions[index * 2],
+					end: editPositions[index * 2 + 1]
+				}
+			})),
+			startLine: changedLineRange.startLine,
+			startCharacter: startPosition.character,
+			endCharacter: endPosition.character,
+			endLine: Math.min(changedLineRange.endLine, Math.max(0, lineCount - 1)),
+			endedAtDocumentEnd,
+			previousLineCount,
+			lineCount,
+			lineDelta: lineCount - previousLineCount,
+			changedLineRanges: changedLineRange.ranges,
+			changedLineChanges: changedLineRange.changes
+		};
+	}
+	#computeChangedLineRange(edits, editPositions) {
+		let startLine = Infinity;
+		let endLine = 0;
+		let lineDeltaBeforeEdit = 0;
+		const ranges = [];
+		const changes = [];
+		const previousLastLine = this.#pieceTable.lineCount - 1;
+		const previousLastLineLength = this.#pieceTable.getLineLength(previousLastLine);
+		for (let i = 0; i < edits.length; i++) {
+			const edit = edits[i];
+			const editStart = editPositions[i * 2];
+			const editEnd = editPositions[i * 2 + 1];
+			const editStartLine = editStart.line;
+			const editEndLine = editEnd.line;
+			const insertedLineSpan = countLineBreaks(edit.text);
+			const changedStartLine = editStartLine + lineDeltaBeforeEdit;
+			const changedEndLine = changedStartLine + insertedLineSpan;
+			const lineDelta = insertedLineSpan - (editEndLine - editStartLine);
+			startLine = Math.min(startLine, editStartLine);
+			endLine = Math.max(endLine, changedEndLine);
+			const lastRange = ranges[ranges.length - 1];
+			if (lastRange !== void 0 && changedStartLine <= lastRange[1] + 1) ranges[ranges.length - 1] = [lastRange[0], Math.max(lastRange[1], changedEndLine)];
+			else ranges.push([changedStartLine, changedEndLine]);
+			changes.push([
+				changedStartLine,
+				changedEndLine,
+				lineDelta,
+				editStart.character,
+				editEnd.character,
+				editEndLine === previousLastLine && editEnd.character === previousLastLineLength
+			]);
+			lineDeltaBeforeEdit += lineDelta;
+		}
+		if (startLine === Infinity) return {
+			startLine: 0,
+			endLine: 0,
+			ranges: [[0, 0]],
+			changes: [[
+				0,
+				0,
+				0,
+				0,
+				0,
+				false
+			]]
+		};
+		return {
+			startLine,
+			endLine,
+			ranges,
+			changes
+		};
+	}
+};
+//#endregion
+export { TextDocument };
+
+//# sourceMappingURL=textDocument.js.map

package/node_modules/@pierre/diffs/dist/editor/textDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textDocument.js","names":["#uri","#languageId","#version","#pieceTable","#editStack","#eol","#applyResolvedEdits","#sortAndValidateResolvedEdits","#resolveEdit","#normalizeResolvedEdit","#applyResolvedEditsToBuffer","#clampIndex","#isInsideSurrogatePair","#computeChangedLineRange"],"sources":["../../src/editor/textDocument.ts"],"sourcesContent":["import type {\n  DiffLineAnnotation,\n  EditorChange,\n  EditorSelection,\n  Position,\n  Range,\n  ResolvedTextEdit,\n  TextEdit,\n} from '../types';\nimport { countLineBreaks } from '../utils/computeFileOffsets';\nimport {\n  coalesceEditStackEntries,\n  createEditStackEntry,\n  EditStack,\n  shouldCoalesceEditStackEntry,\n} from './editStack';\nimport { PieceTable } from './pieceTable';\nimport type { SearchParams } from './searchPanel';\n\nexport type { Position, Range, TextEdit } from '../types';\n\nexport interface TextDocumentChange {\n  /** The edits that were applied to the text document. */\n  readonly changes: EditorChange[];\n  /** First line whose rendered content or tokenizer state may have changed. */\n  readonly startLine: number;\n  /** Character on the first changed line where the edit began. */\n  readonly startCharacter: number;\n  /** Character on the original last changed line where the edit ended. */\n  readonly endCharacter: number;\n  /** Last line whose rendered content may have changed after the edit. */\n  readonly endLine: number;\n  /** Whether the original edit range ended at the previous document EOF. */\n  readonly endedAtDocumentEnd: boolean;\n  /** Line count before the edit was applied. */\n  readonly previousLineCount: number;\n  /** Line count after the edit was applied. */\n  readonly lineCount: number;\n  /** Difference between the old and new line counts. */\n  readonly lineDelta: number;\n  /** Exact rendered line ranges touched by each edit after the edit was applied. */\n  readonly changedLineRanges: readonly [startLine: number, endLine: number][];\n  /** Per-edit rendered line ranges before adjacent ranges are coalesced. */\n  readonly changedLineChanges?: readonly [\n    startLine: number,\n    endLine: number,\n    lineDelta: number,\n    startCharacter?: number,\n    endCharacter?: number,\n    endedAtDocumentEnd?: boolean,\n  ][];\n}\n\n// Metadata-less replay results include the resolved edits so Editor can remap\n// its live selections without storing a snapshot on the history entry.\ntype TextDocumentHistoryResult<LAnnotation> = [\n  change: TextDocumentChange,\n  selections?: EditorSelection[],\n  lineAnnotations?: DiffLineAnnotation<LAnnotation>[],\n  selectionEdits?: ResolvedTextEdit[],\n];\n\n/**\n * A vscode-languageserver-textdocument compatible text document.\n */\nexport class TextDocument<LAnnotation> {\n  #uri: string;\n  #languageId: string;\n  #version: number;\n  #pieceTable: PieceTable;\n  #editStack: EditStack<LAnnotation>;\n  #eol: string;\n\n  constructor(\n    uri: string,\n    text: string,\n    languageId = 'text',\n    version = 0,\n    editStack: EditStack<LAnnotation> = new EditStack()\n  ) {\n    this.#uri = new URL(uri, 'file://').toString();\n    this.#languageId = languageId;\n    this.#version = version;\n    this.#pieceTable = new PieceTable(text);\n    this.#editStack = editStack;\n\n    // The line ending the document uses, detected once from its first line. Lets\n    // inserted or pasted text match the rest of the file instead of leaving\n    // mixed endings behind and keeps that convention stable as the file is\n    // edited. Defaults to Unix `\\n` when the initial text has no line break.\n    const firstLineBreak = this.#pieceTable.getLineText(0, true);\n    if (firstLineBreak.endsWith('\\r\\n')) {\n      this.#eol = '\\r\\n';\n    } else if (firstLineBreak.endsWith('\\r')) {\n      this.#eol = '\\r';\n    } else {\n      this.#eol = '\\n';\n    }\n  }\n\n  get uri(): string {\n    return this.#uri;\n  }\n\n  get languageId(): string {\n    return this.#languageId;\n  }\n\n  get version(): number {\n    return this.#version;\n  }\n\n  get lineCount(): number {\n    return this.#pieceTable.lineCount;\n  }\n\n  get eol(): string {\n    return this.#eol;\n  }\n\n  get canUndo(): boolean {\n    return this.#editStack.canUndo;\n  }\n\n  get canRedo(): boolean {\n    return this.#editStack.canRedo;\n  }\n\n  positionAt(offset: number): Position {\n    return this.normalizePosition(this.#pieceTable.positionAt(offset));\n  }\n\n  positionsAt(offsets: readonly number[]): Position[] {\n    const positions = this.#pieceTable.positionsAt(offsets);\n    for (let i = 0; i < positions.length; i++) {\n      positions[i] = this.normalizePosition(positions[i]);\n    }\n    return positions;\n  }\n\n  offsetAt(position: Position): number {\n    return this.#pieceTable.offsetAt(this.normalizePosition(position));\n  }\n\n  getText(range?: Range): string {\n    if (range === undefined) {\n      return this.#pieceTable.getText();\n    }\n    // Clamp the range to visible line content before extracting text. A\n    // preserved vertical-move \"goal column\" can leave a selection focus whose\n    // character overshoots a shorter line; without this, the piece table clamps\n    // to the line's offset span (which includes the trailing line break) and\n    // copy/cut would pull in that newline. Mirrors `offsetAt`, which normalizes\n    // positions the same way.\n    return this.#pieceTable.getText({\n      start: this.normalizePosition(range.start),\n      end: this.normalizePosition(range.end),\n    });\n  }\n\n  getLineText(line: number, includeLineBreak?: boolean): string {\n    return this.#pieceTable.getLineText(line, includeLineBreak);\n  }\n\n  // Rewrites every line break in `text` to the document's EOL. Clipboard text\n  // can carry Windows (`\\r\\n`) or classic-Mac (`\\r`) breaks; inserting it\n  // verbatim would leave mixed line endings in a file that uses one style.\n  normalizeEol(text: string): string {\n    return text.replace(/\\r\\n|\\r|\\n/g, this.eol);\n  }\n\n  getLineLength(line: number, includeLineBreak?: boolean): number {\n    return this.#pieceTable.getLineLength(line, includeLineBreak);\n  }\n\n  charAt(offset: number): string;\n  charAt(position: Position): string;\n  charAt(positionOrOffset: Position | number): string {\n    if (typeof positionOrOffset === 'number') {\n      return this.#pieceTable.charAt(positionOrOffset);\n    }\n    return this.#pieceTable.charAt(this.offsetAt(positionOrOffset));\n  }\n\n  getTextSlice(start: number, end: number): string {\n    return this.#pieceTable.getTextSlice(start, end);\n  }\n\n  findNextNonOverlappingSubstring(\n    needle: string,\n    occupied: readonly [start: number, end: number][]\n  ): number | undefined {\n    return this.#pieceTable.findNextNonOverlappingSubstring(needle, occupied);\n  }\n\n  search(searchParams: SearchParams): [start: number, end: number][] {\n    return this.#pieceTable.search(searchParams);\n  }\n\n  applyEdits(\n    edits: TextEdit[],\n    updateHistory = true,\n    selectionsBefore?: EditorSelection[],\n    selectionsAfter?: EditorSelection[],\n    undoBoundary = false\n  ): TextDocumentChange | undefined {\n    if (edits.length === 0) {\n      return;\n    }\n    return this.#applyResolvedEdits(\n      this.#sortAndValidateResolvedEdits(this.resolveEdits(edits)),\n      updateHistory,\n      selectionsBefore,\n      selectionsAfter,\n      undoBoundary\n    );\n  }\n\n  // Converts line/character ranges to the exact UTF-16 offsets applyEdits\n  // uses, including widening invalid boundaries so they cannot split a valid\n  // surrogate pair. Editor caret remapping uses the same resolved geometry.\n  resolveEdits(edits: readonly TextEdit[]): ResolvedTextEdit[] {\n    return edits.map((edit) => this.#resolveEdit(edit));\n  }\n\n  applyResolvedEdits(\n    edits: ResolvedTextEdit[],\n    updateHistory = true,\n    selectionsBefore?: EditorSelection[],\n    selectionsAfter?: EditorSelection[],\n    undoBoundary = false\n  ): TextDocumentChange | undefined {\n    if (edits.length === 0) {\n      return undefined;\n    }\n    return this.#applyResolvedEdits(\n      this.#sortAndValidateResolvedEdits(\n        edits.map((edit) => this.#normalizeResolvedEdit(edit))\n      ),\n      updateHistory,\n      selectionsBefore,\n      selectionsAfter,\n      undoBoundary\n    );\n  }\n\n  // Every edit joins the undo timeline: an edit applied with\n  // `updateHistory=false` affects the edit stack exactly as the identical\n  // call with `updateHistory=true` and no selections or undo boundary would.\n  // The flag only controls whether the caller's interaction metadata is\n  // recorded on the entry; the entry itself is always pushed (clearing any\n  // pending redo) and coalesces by the normal geometry rules. This keeps a\n  // mixed tracked/untracked sequence equivalent to the all-tracked sequence —\n  // undo-to-exhaustion restores the original text, redo-to-exhaustion the\n  // final text — instead of leaving frozen entries whose offsets go stale.\n  // Only history replay (undo/redo) writes to the buffer without recording.\n  #applyResolvedEdits(\n    resolvedEdits: ResolvedTextEdit[],\n    updateHistory: boolean,\n    selectionsBefore: EditorSelection[] | undefined,\n    selectionsAfter: EditorSelection[] | undefined,\n    undoBoundary: boolean\n  ): TextDocumentChange {\n    const entry = createEditStackEntry(\n      this,\n      resolvedEdits,\n      this.#version,\n      this.#version + 1,\n      updateHistory ? selectionsBefore : undefined,\n      updateHistory ? selectionsAfter : undefined\n    );\n    if (updateHistory && undoBoundary) {\n      entry.undoBoundary = true;\n    }\n    const previousEntry = this.#editStack.peekUndoForCoalescing();\n    const change = this.#applyResolvedEditsToBuffer(resolvedEdits);\n    this.#version++;\n    if (\n      change.lineDelta === 0 &&\n      shouldCoalesceEditStackEntry(previousEntry, entry)\n    ) {\n      this.#editStack.replaceLastUndo(\n        coalesceEditStackEntries(previousEntry!, entry)\n      );\n    } else {\n      this.#editStack.push(entry);\n    }\n    return change;\n  }\n\n  setLastUndoSelectionsAfter(selections: EditorSelection[]): void {\n    this.#editStack.setLastUndoSelectionsAfter(selections);\n  }\n\n  setLastUndoLineAnnotations(\n    lineAnnotationsBefore: DiffLineAnnotation<LAnnotation>[],\n    lineAnnotationsAfter: DiffLineAnnotation<LAnnotation>[]\n  ): void {\n    this.#editStack.setLastUndoLineAnnotations(\n      lineAnnotationsBefore,\n      lineAnnotationsAfter\n    );\n  }\n\n  undo(): TextDocumentHistoryResult<LAnnotation> | undefined {\n    const entry = this.#editStack.popUndoToRedo();\n    if (entry === undefined) {\n      return undefined;\n    }\n    const change = this.#applyResolvedEditsToBuffer(entry.inverseEdits);\n    if (change === undefined) {\n      return undefined;\n    }\n    this.#version = entry.versionBefore;\n    const selections = entry.selectionsBefore?.slice();\n    return [\n      change,\n      selections,\n      entry.lineAnnotationsBefore?.slice(),\n      selections === undefined\n        ? entry.inverseEdits.map((edit) => ({ ...edit }))\n        : undefined,\n    ];\n  }\n\n  redo(): TextDocumentHistoryResult<LAnnotation> | undefined {\n    const entry = this.#editStack.popRedoToUndo();\n    if (entry === undefined) {\n      return undefined;\n    }\n    const change = this.#applyResolvedEditsToBuffer(entry.forwardEdits);\n    if (change === undefined) {\n      return undefined;\n    }\n    this.#version = entry.versionAfter;\n    const selections = entry.selectionsAfter?.slice();\n    return [\n      change,\n      selections,\n      entry.lineAnnotationsAfter?.slice(),\n      selections === undefined\n        ? entry.forwardEdits.map((edit) => ({ ...edit }))\n        : undefined,\n    ];\n  }\n\n  normalizePosition(position: Position): Position {\n    const line = TextDocument.#clampIndex(position.line, this.lineCount - 1);\n    return {\n      line,\n      character: TextDocument.#clampIndex(\n        position.character,\n        this.getLineLength(line)\n      ),\n    };\n  }\n\n  // Math.min/max pass NaN through, and a fractional index breaks the\n  // integer-keyed line-offset lookup — either way the resolved offset becomes\n  // NaN and a degenerate edit range can swallow the whole document. Malformed\n  // components clamp like any other out-of-range value: NaN and -Infinity act\n  // as 0, fractions floor, +Infinity clamps to the max.\n  static #clampIndex(value: number, max: number): number {\n    if (Number.isNaN(value)) {\n      return 0;\n    }\n    return Math.max(0, Math.min(Math.floor(value), max));\n  }\n\n  #resolveEdit(edit: TextEdit): ResolvedTextEdit {\n    let start = this.offsetAt(edit.range.start);\n    let end = this.offsetAt(edit.range.end);\n    if (start > end) {\n      const t = start;\n      start = end;\n      end = t;\n    }\n    return this.#normalizeResolvedEdit({\n      start,\n      end,\n      text: edit.newText,\n    });\n  }\n\n  // Snaps an insertion before a pair and widens replacement boundaries\n  // outward, so every edit addresses whole UTF-16 surrogate pairs.\n  #normalizeResolvedEdit(edit: ResolvedTextEdit): ResolvedTextEdit {\n    let { start, end } = edit;\n    const isInsertion = start === end;\n    if (this.#isInsideSurrogatePair(start)) {\n      start--;\n    }\n    if (isInsertion) {\n      end = start;\n    } else if (this.#isInsideSurrogatePair(end)) {\n      end++;\n    }\n    return { start, end, text: edit.text };\n  }\n\n  // A UTF-16 offset is invalid when it sits between the high and low units of\n  // one well-formed surrogate pair. Lone surrogate units remain addressable.\n  #isInsideSurrogatePair(offset: number): boolean {\n    const previous = this.#pieceTable.charAt(offset - 1).charCodeAt(0);\n    const next = this.#pieceTable.charAt(offset).charCodeAt(0);\n    return (\n      previous >= 0xd800 &&\n      previous <= 0xdbff &&\n      next >= 0xdc00 &&\n      next <= 0xdfff\n    );\n  }\n\n  #sortAndValidateResolvedEdits(edits: ResolvedTextEdit[]): ResolvedTextEdit[] {\n    // Put zero-width edits before ranges at the same start so validation and\n    // application do not depend on the caller's batch order.\n    const sortedEdits = [...edits].sort((a, b) => {\n      const startDelta = a.start - b.start;\n      return startDelta === 0 ? a.end - b.end : startDelta;\n    });\n    for (let i = 0; i < sortedEdits.length - 1; i++) {\n      if (sortedEdits[i].end > sortedEdits[i + 1].start) {\n        throw new Error('Overlapping text edits are not supported');\n      }\n    }\n    return sortedEdits;\n  }\n\n  #applyResolvedEditsToBuffer(edits: ResolvedTextEdit[]): TextDocumentChange {\n    const previousLineCount = this.#pieceTable.lineCount;\n    const editPositions = this.positionsAt(\n      edits.flatMap((edit) => [edit.start, edit.end])\n    );\n    const changedLineRange = this.#computeChangedLineRange(\n      edits,\n      editPositions\n    );\n    const startPosition = editPositions[0];\n    const endPosition = editPositions[editPositions.length - 1];\n    const endedAtDocumentEnd =\n      endPosition.line === previousLineCount - 1 &&\n      endPosition.character ===\n        this.#pieceTable.getLineLength(endPosition.line);\n    this.#pieceTable.applyEdits(edits);\n    const lineCount = this.#pieceTable.lineCount;\n    const change: TextDocumentChange = {\n      changes: edits.map((edit, index) => ({\n        ...edit,\n        range: {\n          start: editPositions[index * 2],\n          end: editPositions[index * 2 + 1],\n        },\n      })),\n      startLine: changedLineRange.startLine,\n      startCharacter: startPosition.character,\n      endCharacter: endPosition.character,\n      endLine: Math.min(changedLineRange.endLine, Math.max(0, lineCount - 1)),\n      endedAtDocumentEnd,\n      previousLineCount,\n      lineCount,\n      lineDelta: lineCount - previousLineCount,\n      changedLineRanges: changedLineRange.ranges,\n      changedLineChanges: changedLineRange.changes,\n    };\n    return change;\n  }\n\n  #computeChangedLineRange(\n    edits: ResolvedTextEdit[],\n    editPositions: Position[]\n  ): {\n    startLine: number;\n    endLine: number;\n    ranges: [number, number][];\n    changes: [\n      startLine: number,\n      endLine: number,\n      lineDelta: number,\n      startCharacter: number,\n      endCharacter: number,\n      endedAtDocumentEnd: boolean,\n    ][];\n  } {\n    let startLine = Infinity;\n    let endLine = 0;\n    let lineDeltaBeforeEdit = 0;\n    const ranges: [number, number][] = [];\n    const changes: [\n      startLine: number,\n      endLine: number,\n      lineDelta: number,\n      startCharacter: number,\n      endCharacter: number,\n      endedAtDocumentEnd: boolean,\n    ][] = [];\n    const previousLastLine = this.#pieceTable.lineCount - 1;\n    const previousLastLineLength =\n      this.#pieceTable.getLineLength(previousLastLine);\n    for (let i = 0; i < edits.length; i++) {\n      const edit = edits[i];\n      const editStart = editPositions[i * 2];\n      const editEnd = editPositions[i * 2 + 1];\n      const editStartLine = editStart.line;\n      const editEndLine = editEnd.line;\n      const insertedLineSpan = countLineBreaks(edit.text);\n      const changedStartLine = editStartLine + lineDeltaBeforeEdit;\n      const changedEndLine = changedStartLine + insertedLineSpan;\n      const lineDelta = insertedLineSpan - (editEndLine - editStartLine);\n      startLine = Math.min(startLine, editStartLine);\n      endLine = Math.max(endLine, changedEndLine);\n      const lastRange = ranges[ranges.length - 1];\n      if (lastRange !== undefined && changedStartLine <= lastRange[1] + 1) {\n        ranges[ranges.length - 1] = [\n          lastRange[0],\n          Math.max(lastRange[1], changedEndLine),\n        ];\n      } else {\n        ranges.push([changedStartLine, changedEndLine]);\n      }\n      changes.push([\n        changedStartLine,\n        changedEndLine,\n        lineDelta,\n        editStart.character,\n        editEnd.character,\n        editEndLine === previousLastLine &&\n          editEnd.character === previousLastLineLength,\n      ]);\n      lineDeltaBeforeEdit += lineDelta;\n    }\n    if (startLine === Infinity) {\n      return {\n        startLine: 0,\n        endLine: 0,\n        ranges: [[0, 0]],\n        changes: [[0, 0, 0, 0, 0, false]],\n      };\n    }\n    return { startLine, endLine, ranges, changes };\n  }\n}\n"],"mappings":"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"}

package/node_modules/@pierre/diffs/dist/editor/textMeasure.d.ts

@@ -0,0 +1,61 @@
+//#region src/editor/textMeasure.d.ts
+declare class Metrics {
+  #private;
+  /** Width of the '0' character. */
+  ch: number;
+  /** Size of a tab(\t) character. */
+  tabSize: number;
+  /** Height of the code line. */
+  lineHeight: number;
+  /** Padding top of the root element. */
+  paddingTop: number;
+  /** initialize the metrics */
+  init(root: HTMLElement): void;
+  /**
+   * Re-measure the '0' character width against the font that is loaded right
+   * now, returning true when measurement-dependent UI should refresh.
+   *
+   * A custom web font can finish loading after the editor first renders.
+   * Until then canvas measureText reports the fallback font's width, and
+   * getComputedStyle returns the same font-family string before and after the
+   * file arrives, so init()'s font guard never re-measures on its own. Call
+   * this once fonts have settled (e.g. on document.fonts.ready) to replace a
+   * width measured against the fallback font with the real glyph width. Font
+   * completion can also change DOM-measured emoji/ZWJ widths while leaving the
+   * ASCII width unchanged, and the computed font string stays the same in both
+   * cases. The boolean return lets the caller skip re-rendering when there is no
+   * measured state to refresh.
+   */
+  remeasureCharacterWidth(): boolean;
+  /** measure the width of the text */
+  measureTextWidth(text: string): number;
+  /** measure the width of the text using the canvas measureText API */
+  canvasMeasureTextWidth(text: string): number;
+  /**
+   * measure the width of the text using the DOM
+   * this is slow because it cause a reflow, use it for non-ascii text;
+   * results are memoized per text so repeated measurements skip the reflow
+   */
+  domMeasureTextWidth(text: string): number;
+  /**
+   * discard memoized DOM text widths
+   * call this when the inherited font may have changed without re-running
+   * init(), e.g. on a layout reflow, so stale widths are not reused
+   */
+  clearTextWidthCache(): void;
+}
+/** Check if the text needs DOM text measurement. */
+declare function needsDomTextMeasurement(text: string): boolean;
+/** snap the text offset to the Unicode boundary */
+declare function snapTextOffsetToUnicodeBoundary(text: string, offset: number): number;
+/** get the offsets of the Unicode grapheme clusters in the text */
+declare function getUnicodeMeasurementOffsets(text: string): number[] | undefined;
+/**
+ * Count the rendered columns of ASCII text, advancing each tab to the next
+ * fixed tab stop (a multiple of tabSize) to match CSS `tab-size`. Returns -1
+ * for non-ASCII text, which must be measured glyph-by-glyph instead.
+ */
+declare function getExpandedAsciiTextColumns(text: string, tabSize: number): number;
+//#endregion
+export { Metrics, getExpandedAsciiTextColumns, getUnicodeMeasurementOffsets, needsDomTextMeasurement, snapTextOffsetToUnicodeBoundary };
+//# sourceMappingURL=textMeasure.d.ts.map

package/node_modules/@pierre/diffs/dist/editor/textMeasure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textMeasure.d.ts","names":[],"sources":["../../src/editor/textMeasure.ts"],"mappings":";cAUa,OAAA;EAAA;EAAO;EASlB,EAAA;EASsB;EAPtB,OAAA;EAFA;EAIA,UAAA;EAAA;EAEA,UAAA;EAGA;EAAA,IAAA,CAAK,IAAA,EAAM,WAAW;EAAjB;;;;;;;;;;AAyLc;AAYrB;;;;EAtIE,uBAAA;EAuJc;EAxId,gBAAA,CAAiB,IAAA;;EA8CjB,sBAAA,CAAuB,IAAA;EA4FT;AA6ChB;;;;EA7HE,mBAAA,CAAoB,IAAA;EAyJN;;;;AAEC;EA1Gf,mBAAA;AAAA;;iBAYc,uBAAA,CAAwB,IAAY;;iBAiBpC,+BAAA,CACd,IAAA,UACA,MAAc;;iBA6CA,4BAAA,CACd,IAAY;;;;;;iBA2BE,2BAAA,CACd,IAAA,UACA,OAAe"}