@singapore-editor/tree-sitter 0.1.1

package/dist/structuralSelection.js

@@ -0,0 +1,139 @@
+import { createAnchorSelection, normalizeSelectionSet, resolveSelection } from "@singapore-editor/core/document";
+//#region src/structuralSelection.ts
+/**
+* The nesting the grammar found, as one unordered bucket for the editor's selection ladder to rank.
+*
+* Fold ranges are node ranges the parse has already published, so expand climbs exactly the nesting
+* the gutter offers to collapse rather than a second, differently shaped idea of what encloses what.
+* The fold query only reports nodes that span lines, so a construct written on one line is left to
+* the word and line rungs.
+*/
+var treeSitterSelectionRanges = (folds) => folds.map((fold) => ({
+	start: fold.startIndex,
+	end: fold.endIndex
+}));
+var selectTreeSitterToken = async (options) => {
+	const input = normalizedSelectionInput(options);
+	return selectionCommandResult(options, input, await requestSelectionRanges(options, input.ranges, "selectToken"), (range) => [range]);
+};
+var expandTreeSitterSelection = async (options) => {
+	const input = normalizedSelectionInput(options);
+	return selectionCommandResult(options, input, await requestSelectionRanges(options, input.ranges, "expand"), (range, index) => {
+		const stack = stackForSelection(options, index, input.ranges[index]);
+		const previous = stack.at(-1);
+		if (previous && rangesEqual(previous, range)) return stack;
+		return [...stack, range];
+	});
+};
+var shrinkTreeSitterSelection = (options) => {
+	const input = normalizedSelectionInput(options);
+	const ranges = rangesFromShrinkState(options, input.ranges);
+	if (!ranges) return noOpSelectionCommandResult(options, input, "stale");
+	const stacks = options.state.stacks.map((stack) => stack.slice(0, -1));
+	const settled = settleSelectionRanges(options.snapshot, input, ranges, stacks);
+	return {
+		selections: settled.selections,
+		state: {
+			snapshotVersion: options.snapshotVersion,
+			stacks: settled.stacks
+		},
+		status: "ok"
+	};
+};
+var requestSelectionRanges = (options, ranges, action) => options.backend.select({
+	documentId: options.documentId,
+	runtimeSessionId: options.runtimeSessionId,
+	languageId: options.languageId,
+	snapshotVersion: options.snapshotVersion,
+	action,
+	ranges
+});
+var selectionCommandResult = (options, input, result, nextStack) => {
+	if (!result || result.status === "stale") return noOpSelectionCommandResult(options, input, "stale");
+	if (result.ranges.length !== input.sources.length) return noOpSelectionCommandResult(options, input, "stale");
+	const stacks = result.ranges.map(nextStack);
+	const settled = settleSelectionRanges(options.snapshot, input, result.ranges, stacks);
+	return {
+		selections: settled.selections,
+		state: {
+			snapshotVersion: options.snapshotVersion,
+			stacks: settled.stacks
+		},
+		status: "ok"
+	};
+};
+var noOpSelectionCommandResult = (options, input, status) => ({
+	selections: options.selections,
+	state: options.state ?? {
+		snapshotVersion: options.snapshotVersion,
+		stacks: input.ranges.map((range) => [range])
+	},
+	status
+});
+var normalizedSelectionInput = (options) => {
+	const selections = normalizeSelectionSet(options.snapshot, options.selections);
+	const sources = selections.selections.map((selection) => resolveSelection(options.snapshot, selection));
+	return {
+		selections,
+		sources,
+		ranges: sources.map(selectionRange)
+	};
+};
+var settleSelectionRanges = (snapshot, input, ranges, stacks) => {
+	const selections = ranges.map((range, index) => {
+		const source = input.sources[index];
+		return createAnchorSelection(snapshot, range.startIndex, range.endIndex, {
+			affinity: source?.affinity,
+			id: source?.id,
+			reversed: source?.reversed ?? false
+		});
+	});
+	const normalized = normalizeSelectionSet(snapshot, {
+		selections,
+		lastAddedIndex: input.selections.lastAddedIndex,
+		normalized: false
+	});
+	const stackById = new Map(input.sources.map((source, index) => [source.id, stacks[index] ?? []]));
+	return {
+		selections: normalized,
+		stacks: normalized.selections.map((selection) => {
+			const resolved = resolveSelection(snapshot, selection);
+			return stackWithTop(stackById.get(resolved.id) ?? [], selectionRange(resolved));
+		})
+	};
+};
+var rangesFromShrinkState = (options, selected) => {
+	if (!options.state) return null;
+	if (options.state.snapshotVersion !== options.snapshotVersion) return null;
+	if (options.state.stacks.length !== selected.length) return null;
+	const ranges = options.state.stacks.map((stack, index) => {
+		const top = stack.at(-1);
+		const current = selected[index];
+		if (!top || !current || !rangesEqual(top, current)) return void 0;
+		return stack.at(-2) ?? top;
+	});
+	if (ranges.some((range) => !range)) return null;
+	return ranges;
+};
+var selectionRange = (selection) => ({
+	startIndex: selection.startOffset,
+	endIndex: selection.endOffset
+});
+var stackWithTop = (stack, range) => {
+	const top = stack.at(-1);
+	if (top && rangesEqual(top, range)) return stack;
+	if (stack.length === 0) return [range];
+	return [...stack.slice(0, -1), range];
+};
+var stackForSelection = (options, index, selected) => {
+	if (!selected) return [];
+	if (options.state?.snapshotVersion !== options.snapshotVersion) return [selected];
+	const stack = options.state.stacks[index];
+	const top = stack?.at(-1);
+	return stack && top && rangesEqual(top, selected) ? stack : [selected];
+};
+var rangesEqual = (left, right) => left.startIndex === right.startIndex && left.endIndex === right.endIndex;
+//#endregion
+export { expandTreeSitterSelection, selectTreeSitterToken, shrinkTreeSitterSelection, treeSitterSelectionRanges };
+
+//# sourceMappingURL=structuralSelection.js.map

package/dist/structuralSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structuralSelection.js","names":[],"sources":["../src/structuralSelection.ts"],"sourcesContent":["import type { PieceTableSnapshot, TextOffsetRange } from '@singapore-editor/core/document'\nimport type { FoldRange } from '@singapore-editor/core/syntax'\nimport {\n  createAnchorSelection,\n  normalizeSelectionSet,\n  type PieceTableAnchor,\n  resolveSelection,\n  type SelectionSet,\n} from '@singapore-editor/core/document'\nimport type { TreeSitterBackend } from './treeSitter/workerClient'\nimport type {\n  TreeSitterLanguageId,\n  TreeSitterSelectionRange,\n  TreeSitterSelectionResult,\n} from './treeSitter/types'\n\nexport type TreeSitterSelectionExpansionState = {\n  readonly snapshotVersion: number\n  readonly stacks: readonly (readonly TreeSitterSelectionRange[])[]\n}\n\nexport type TreeSitterSelectionCommandOptions = {\n  readonly documentId: string\n  readonly runtimeSessionId: string\n  readonly languageId: TreeSitterLanguageId\n  readonly snapshotVersion: number\n  readonly snapshot: PieceTableSnapshot\n  readonly selections: SelectionSet<PieceTableAnchor>\n  readonly backend: Pick<TreeSitterBackend, 'select'>\n  readonly state?: TreeSitterSelectionExpansionState\n}\n\nexport type TreeSitterSelectionCommandResult = {\n  readonly selections: SelectionSet<PieceTableAnchor>\n  readonly state: TreeSitterSelectionExpansionState\n  readonly status: 'ok' | 'stale'\n}\n\ntype NormalizedSelectionInput = {\n  readonly selections: SelectionSet<PieceTableAnchor>\n  readonly sources: readonly ResolvedSelection[]\n  readonly ranges: readonly TreeSitterSelectionRange[]\n}\n\ntype ResolvedSelection = ReturnType<typeof resolveSelection>\n\ntype SettledSelectionResult = {\n  readonly selections: SelectionSet<PieceTableAnchor>\n  readonly stacks: readonly (readonly TreeSitterSelectionRange[])[]\n}\n\n/**\n * The nesting the grammar found, as one unordered bucket for the editor's selection ladder to rank.\n *\n * Fold ranges are node ranges the parse has already published, so expand climbs exactly the nesting\n * the gutter offers to collapse rather than a second, differently shaped idea of what encloses what.\n * The fold query only reports nodes that span lines, so a construct written on one line is left to\n * the word and line rungs.\n */\nexport const treeSitterSelectionRanges = (\n  folds: readonly FoldRange[],\n): readonly TextOffsetRange[] =>\n  folds.map((fold) => ({ start: fold.startIndex, end: fold.endIndex }))\n\nexport const selectTreeSitterToken = async (\n  options: TreeSitterSelectionCommandOptions,\n): Promise<TreeSitterSelectionCommandResult> => {\n  const input = normalizedSelectionInput(options)\n  const result = await requestSelectionRanges(options, input.ranges, 'selectToken')\n  return selectionCommandResult(options, input, result, (range) => [range])\n}\n\nexport const expandTreeSitterSelection = async (\n  options: TreeSitterSelectionCommandOptions,\n): Promise<TreeSitterSelectionCommandResult> => {\n  const input = normalizedSelectionInput(options)\n  const result = await requestSelectionRanges(options, input.ranges, 'expand')\n  return selectionCommandResult(options, input, result, (range, index) => {\n    const stack = stackForSelection(options, index, input.ranges[index])\n    const previous = stack.at(-1)\n    if (previous && rangesEqual(previous, range)) return stack\n    return [...stack, range]\n  })\n}\n\nexport const shrinkTreeSitterSelection = (\n  options: TreeSitterSelectionCommandOptions,\n): TreeSitterSelectionCommandResult => {\n  const input = normalizedSelectionInput(options)\n  const ranges = rangesFromShrinkState(options, input.ranges)\n  if (!ranges) return noOpSelectionCommandResult(options, input, 'stale')\n\n  const stacks = options.state!.stacks.map((stack) => stack.slice(0, -1))\n  const settled = settleSelectionRanges(options.snapshot, input, ranges, stacks)\n\n  return {\n    selections: settled.selections,\n    state: {\n      snapshotVersion: options.snapshotVersion,\n      stacks: settled.stacks,\n    },\n    status: 'ok',\n  }\n}\n\nconst requestSelectionRanges = (\n  options: TreeSitterSelectionCommandOptions,\n  ranges: readonly TreeSitterSelectionRange[],\n  action: 'selectToken' | 'expand',\n): Promise<TreeSitterSelectionResult | undefined> =>\n  options.backend.select({\n    documentId: options.documentId,\n    runtimeSessionId: options.runtimeSessionId,\n    languageId: options.languageId,\n    snapshotVersion: options.snapshotVersion,\n    action,\n    ranges,\n  })\n\nconst selectionCommandResult = (\n  options: TreeSitterSelectionCommandOptions,\n  input: NormalizedSelectionInput,\n  result: TreeSitterSelectionResult | undefined,\n  nextStack: (\n    range: TreeSitterSelectionRange,\n    index: number,\n  ) => readonly TreeSitterSelectionRange[],\n): TreeSitterSelectionCommandResult => {\n  if (!result || result.status === 'stale') {\n    return noOpSelectionCommandResult(options, input, 'stale')\n  }\n  if (result.ranges.length !== input.sources.length) {\n    return noOpSelectionCommandResult(options, input, 'stale')\n  }\n\n  const stacks = result.ranges.map(nextStack)\n  const settled = settleSelectionRanges(options.snapshot, input, result.ranges, stacks)\n\n  return {\n    selections: settled.selections,\n    state: {\n      snapshotVersion: options.snapshotVersion,\n      stacks: settled.stacks,\n    },\n    status: 'ok',\n  }\n}\n\nconst noOpSelectionCommandResult = (\n  options: TreeSitterSelectionCommandOptions,\n  input: NormalizedSelectionInput,\n  status: 'ok' | 'stale',\n): TreeSitterSelectionCommandResult => ({\n  selections: options.selections,\n  state: options.state ?? {\n    snapshotVersion: options.snapshotVersion,\n    stacks: input.ranges.map((range) => [range]),\n  },\n  status,\n})\n\nconst normalizedSelectionInput = (\n  options: TreeSitterSelectionCommandOptions,\n): NormalizedSelectionInput => {\n  const selections = normalizeSelectionSet(options.snapshot, options.selections)\n  const sources = selections.selections.map((selection) =>\n    resolveSelection(options.snapshot, selection),\n  )\n  return {\n    selections,\n    sources,\n    ranges: sources.map(selectionRange),\n  }\n}\n\nconst settleSelectionRanges = (\n  snapshot: PieceTableSnapshot,\n  input: NormalizedSelectionInput,\n  ranges: readonly TreeSitterSelectionRange[],\n  stacks: readonly (readonly TreeSitterSelectionRange[])[],\n): SettledSelectionResult => {\n  const selections = ranges.map((range, index) => {\n    const source = input.sources[index]\n    return createAnchorSelection(snapshot, range.startIndex, range.endIndex, {\n      affinity: source?.affinity,\n      id: source?.id,\n      // Which end leads is the user's, not the tree's: a selection dragged right to left keeps\n      // growing away from its anchor.\n      reversed: source?.reversed ?? false,\n    })\n  })\n\n  const normalized = normalizeSelectionSet(snapshot, {\n    selections,\n    lastAddedIndex: input.selections.lastAddedIndex,\n    normalized: false,\n  })\n  const stackById = new Map(\n    input.sources.map((source, index) => [source.id, stacks[index] ?? []] as const),\n  )\n  const settledStacks = normalized.selections.map((selection) => {\n    const resolved = resolveSelection(snapshot, selection)\n    return stackWithTop(stackById.get(resolved.id) ?? [], selectionRange(resolved))\n  })\n\n  return { selections: normalized, stacks: settledStacks }\n}\n\nconst rangesFromShrinkState = (\n  options: TreeSitterSelectionCommandOptions,\n  selected: readonly TreeSitterSelectionRange[],\n): readonly TreeSitterSelectionRange[] | null => {\n  if (!options.state) return null\n  if (options.state.snapshotVersion !== options.snapshotVersion) return null\n\n  if (options.state.stacks.length !== selected.length) return null\n\n  const ranges = options.state.stacks.map((stack, index) => {\n    const top = stack.at(-1)\n    const current = selected[index]\n    if (!top || !current || !rangesEqual(top, current)) return undefined\n    return stack.at(-2) ?? top\n  })\n  if (ranges.some((range) => !range)) return null\n  return ranges as readonly TreeSitterSelectionRange[]\n}\n\nconst selectionRange = (selection: ResolvedSelection): TreeSitterSelectionRange => ({\n  startIndex: selection.startOffset,\n  endIndex: selection.endOffset,\n})\n\nconst stackWithTop = (\n  stack: readonly TreeSitterSelectionRange[],\n  range: TreeSitterSelectionRange,\n): readonly TreeSitterSelectionRange[] => {\n  const top = stack.at(-1)\n  if (top && rangesEqual(top, range)) return stack\n  if (stack.length === 0) return [range]\n  return [...stack.slice(0, -1), range]\n}\n\nconst stackForSelection = (\n  options: TreeSitterSelectionCommandOptions,\n  index: number,\n  selected: TreeSitterSelectionRange | undefined,\n): readonly TreeSitterSelectionRange[] => {\n  if (!selected) return []\n  if (options.state?.snapshotVersion !== options.snapshotVersion) return [selected]\n\n  const stack = options.state.stacks[index]\n  const top = stack?.at(-1)\n  return stack && top && rangesEqual(top, selected) ? stack : [selected]\n}\n\nconst rangesEqual = (left: TreeSitterSelectionRange, right: TreeSitterSelectionRange): boolean =>\n  left.startIndex === right.startIndex && left.endIndex === right.endIndex\n"],"mappings":"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"}

package/dist/treeSitter/markdown.d.ts

@@ -0,0 +1,12 @@
+import { MarkdownDocument } from 'tree-sitter-md';
+import { type Node, type Range } from 'web-tree-sitter';
+import type { TextEdit } from '@singapore-editor/core/document';
+import type { FoldRange, TreeSitterCapture, TreeSitterSyntaxRange } from './types';
+export declare const initializeMarkdown: () => Promise<void>;
+export declare function editMarkdown(document: MarkdownDocument, edits: readonly TextEdit[]): void;
+export declare function markdownCaptures(document: MarkdownDocument, range: TreeSitterSyntaxRange): TreeSitterCapture[];
+export declare function markdownFolds(document: MarkdownDocument, range: TreeSitterSyntaxRange): FoldRange[];
+export declare function markdownRange(document: MarkdownDocument, startIndex: number, endIndex: number): Range;
+export declare function markdownMdxSource(text: string, root: Node, offset?: number): string;
+export declare function markdownRecords(document: MarkdownDocument, range: TreeSitterSyntaxRange): Uint32Array;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/treeSitter/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/treeSitter/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGvE,OAAO,EAAY,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGlF,eAAO,MAAM,kBAAkB,QAAO,OAAO,CAAC,IAAI,CAQjD,CAAA;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CAIzF;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,qBAAqB,GAC3B,iBAAiB,EAAE,CAuBrB;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,qBAAqB,GAC3B,SAAS,EAAE,CAmBb;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,KAAK,CAOP;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAI,GAAG,MAAM,CAe9E;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,qBAAqB,GAC3B,WAAW,CAqBb"}

package/dist/treeSitter/registry.d.ts

@@ -0,0 +1,56 @@
+export type TreeSitterLanguageId = string;
+export type TreeSitterLanguageAssets = {
+    readonly wasmUrl: string;
+    readonly highlightQuerySource?: string;
+    readonly foldQuerySource?: string;
+    readonly injectionQuerySource?: string;
+};
+type TreeSitterLanguageContributionMetadata = {
+    readonly id: TreeSitterLanguageId;
+    readonly extensions?: readonly string[];
+    readonly aliases?: readonly string[];
+    readonly filenames?: readonly string[];
+    readonly injectionDependencies?: readonly string[];
+};
+type TreeSitterInlineLanguageContribution = TreeSitterLanguageContributionMetadata & TreeSitterLanguageAssets & {
+    readonly load?: never;
+};
+type TreeSitterLazyLanguageContribution = TreeSitterLanguageContributionMetadata & {
+    readonly load: () => Promise<TreeSitterLanguageAssets>;
+};
+export type TreeSitterLanguageContribution = TreeSitterInlineLanguageContribution | TreeSitterLazyLanguageContribution;
+export type TreeSitterLanguageDescriptor = TreeSitterLanguageContributionMetadata & TreeSitterLanguageAssets & {
+    readonly extensions: readonly string[];
+    readonly aliases: readonly string[];
+};
+export type TreeSitterLanguageRegistrationOptions = {
+    readonly replace?: boolean;
+};
+export type TreeSitterLanguageDisposable = {
+    dispose(): void;
+};
+export type TreeSitterLanguageResolver = {
+    resolveTreeSitterLanguage(languageId: TreeSitterLanguageId): Promise<TreeSitterLanguageDescriptor | null>;
+};
+export declare class TreeSitterLanguageRegistry implements TreeSitterLanguageResolver {
+    private readonly registrations;
+    registerLanguage(contribution: TreeSitterLanguageContribution, options?: TreeSitterLanguageRegistrationOptions): TreeSitterLanguageDisposable;
+    hasLanguage(languageId: string | null | undefined): boolean;
+    resolveLanguageAlias(alias: string | null | undefined): TreeSitterLanguageId | null;
+    resolveTreeSitterLanguage(languageId: TreeSitterLanguageId): Promise<TreeSitterLanguageDescriptor | null>;
+    clear(): void;
+    private assertCanRegister;
+    private unregisterLanguage;
+    private findActiveRegistration;
+    private activeRegistrationForId;
+    private isActiveRegistration;
+}
+export declare const createTreeSitterLanguageRegistry: () => TreeSitterLanguageRegistry;
+export declare const resolveTreeSitterLanguageContribution: (contribution: TreeSitterLanguageContribution) => Promise<TreeSitterLanguageDescriptor>;
+/** A language's descriptor followed by every language its injection queries name, transitively. */
+export declare const resolveTreeSitterLanguageClosure: (resolver: TreeSitterLanguageResolver, languageId: TreeSitterLanguageId, isCancelled?: () => boolean) => Promise<readonly TreeSitterLanguageDescriptor[]>;
+export declare const withInjectedLanguages: (resolver: TreeSitterLanguageResolver | undefined, descriptor: TreeSitterLanguageDescriptor, isCancelled: () => boolean) => Promise<readonly TreeSitterLanguageDescriptor[]>;
+export declare const resolveTreeSitterLanguageAlias: (alias: string | null | undefined, registry?: TreeSitterLanguageRegistry) => TreeSitterLanguageId | null;
+export declare const isTreeSitterLanguageId: (languageId: string | null | undefined) => languageId is TreeSitterLanguageId;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/treeSitter/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/treeSitter/registry.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAA;AAEzC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CACvC,CAAA;AAED,KAAK,sCAAsC,GAAG;IAC5C,QAAQ,CAAC,EAAE,EAAE,oBAAoB,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACnD,CAAA;AAED,KAAK,oCAAoC,GAAG,sCAAsC,GAChF,wBAAwB,GAAG;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAA;CACtB,CAAA;AAEH,KAAK,kCAAkC,GAAG,sCAAsC,GAAG;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,wBAAwB,CAAC,CAAA;CACvD,CAAA;AAED,MAAM,MAAM,8BAA8B,GACtC,oCAAoC,GACpC,kCAAkC,CAAA;AAEtC,MAAM,MAAM,4BAA4B,GAAG,sCAAsC,GAC/E,wBAAwB,GAAG;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC,CAAA;AAEH,MAAM,MAAM,qCAAqC,GAAG;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,IAAI,IAAI,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,yBAAyB,CACvB,UAAU,EAAE,oBAAoB,GAC/B,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAAA;CAChD,CAAA;AASD,qBAAa,0BAA2B,YAAW,0BAA0B;IAC3E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuC;IAE9D,gBAAgB,CACrB,YAAY,EAAE,8BAA8B,EAC5C,OAAO,GAAE,qCAA0C,GAClD,4BAA4B;IAUxB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAM3D,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,oBAAoB,GAAG,IAAI;IAW7E,yBAAyB,CACpC,UAAU,EAAE,oBAAoB,GAC/B,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;IAcxC,KAAK,IAAI,IAAI;IAIpB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,uBAAuB;IAW/B,OAAO,CAAC,oBAAoB;CAG7B;AAED,eAAO,MAAM,gCAAgC,QAAO,0BAClB,CAAA;AAElC,eAAO,MAAM,qCAAqC,GAChD,cAAc,8BAA8B,KAC3C,OAAO,CAAC,4BAA4B,CAGtC,CAAA;AAED,mGAAmG;AACnG,eAAO,MAAM,gCAAgC,GAC3C,UAAU,0BAA0B,EACpC,YAAY,oBAAoB,EAChC,cAAa,MAAM,OAAqB,KACvC,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAIjD,CAAA;AAED,eAAO,MAAM,qBAAqB,GAChC,UAAU,0BAA0B,GAAG,SAAS,EAChD,YAAY,4BAA4B,EACxC,aAAa,MAAM,OAAO,KACzB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAajD,CAAA;AAED,eAAO,MAAM,8BAA8B,GACzC,OAAO,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,WAAW,0BAA0B,KACpC,oBAAoB,GAAG,IAAqD,CAAA;AAE/E,eAAO,MAAM,sBAAsB,GACjC,YAAY,MAAM,GAAG,IAAI,GAAG,SAAS,KACpC,UAAU,IAAI,oBAAwE,CAAA"}

package/dist/treeSitter/registry.js

@@ -0,0 +1,144 @@
+//#region src/treeSitter/registry.ts
+var TreeSitterLanguageRegistry = class {
+	registrations = [];
+	registerLanguage(contribution, options = {}) {
+		const registration = createRegistration(contribution);
+		this.assertCanRegister(registration.id, options);
+		this.registrations.push(registration);
+		return { dispose: () => this.unregisterLanguage(registration) };
+	}
+	hasLanguage(languageId) {
+		const id = normalizeOptionalLanguageId(languageId);
+		if (!id) return false;
+		return this.activeRegistrationForId(id) !== null;
+	}
+	resolveLanguageAlias(alias) {
+		const normalized = normalizeOptionalAlias(alias);
+		if (!normalized) return null;
+		return this.findActiveRegistration((candidate) => {
+			if (candidate.id.toLowerCase() === normalized) return true;
+			return candidate.aliases.includes(normalized);
+		})?.id ?? null;
+	}
+	async resolveTreeSitterLanguage(languageId) {
+		const id = this.resolveLanguageAlias(languageId) ?? normalizeLanguageId(languageId);
+		const registration = this.activeRegistrationForId(id);
+		if (!registration) return null;
+		if (!registration.descriptorPromise) registration.descriptorPromise = resolveTreeSitterLanguageContribution(registration.contribution);
+		return registration.descriptorPromise;
+	}
+	clear() {
+		this.registrations.length = 0;
+	}
+	assertCanRegister(languageId, options) {
+		if (options.replace) return;
+		if (!this.hasLanguage(languageId)) return;
+		throw new Error(`Tree-sitter language "${languageId}" is already registered`);
+	}
+	unregisterLanguage(registration) {
+		const index = this.registrations.indexOf(registration);
+		if (index === -1) return;
+		this.registrations.splice(index, 1);
+	}
+	findActiveRegistration(predicate) {
+		for (let index = this.registrations.length - 1; index >= 0; index -= 1) {
+			const registration = this.registrations[index];
+			if (!this.isActiveRegistration(registration)) continue;
+			if (predicate(registration)) return registration;
+		}
+		return null;
+	}
+	activeRegistrationForId(languageId) {
+		for (let index = this.registrations.length - 1; index >= 0; index -= 1) {
+			const registration = this.registrations[index];
+			if (registration.id === languageId) return registration;
+		}
+		return null;
+	}
+	isActiveRegistration(registration) {
+		return this.activeRegistrationForId(registration.id) === registration;
+	}
+};
+var createTreeSitterLanguageRegistry = () => new TreeSitterLanguageRegistry();
+var resolveTreeSitterLanguageContribution = async (contribution) => {
+	return createTreeSitterLanguageDescriptor(contribution, await loadTreeSitterLanguageAssets(contribution));
+};
+/** A language's descriptor followed by every language its injection queries name, transitively. */
+var resolveTreeSitterLanguageClosure = async (resolver, languageId, isCancelled = () => false) => {
+	const descriptor = await resolver.resolveTreeSitterLanguage(languageId);
+	if (!descriptor || isCancelled()) return [];
+	return withInjectedLanguages(resolver, descriptor, isCancelled);
+};
+var withInjectedLanguages = async (resolver, descriptor, isCancelled) => {
+	const descriptors = [descriptor];
+	const seen = /* @__PURE__ */ new Set([descriptor.id]);
+	for (let index = 0; index < descriptors.length; index += 1) {
+		const dependencies = descriptors[index]?.injectionDependencies ?? [];
+		for (const id of dependencies) {
+			if (seen.has(id) || isCancelled()) continue;
+			seen.add(id);
+			const injected = await resolver?.resolveTreeSitterLanguage(id);
+			if (injected) descriptors.push(injected);
+		}
+	}
+	return descriptors;
+};
+var resolveTreeSitterLanguageAlias = (alias, registry) => registry?.resolveLanguageAlias(alias) ?? null;
+var isTreeSitterLanguageId = (languageId) => normalizeOptionalLanguageId(languageId) !== null;
+var createRegistration = (contribution) => ({
+	contribution,
+	id: normalizeLanguageId(contribution.id),
+	aliases: uniqueItems((contribution.aliases ?? []).map(normalizeAlias)),
+	descriptorPromise: null
+});
+var createTreeSitterLanguageDescriptor = (contribution, assets) => ({
+	id: normalizeLanguageId(contribution.id),
+	extensions: uniqueItems((contribution.extensions ?? []).map(normalizeExtension)),
+	aliases: uniqueItems((contribution.aliases ?? []).map(normalizeAlias)),
+	filenames: contribution.filenames ?? [],
+	injectionDependencies: contribution.injectionDependencies ?? [],
+	wasmUrl: normalizeWasmUrl(assets.wasmUrl, contribution.id),
+	highlightQuerySource: assets.highlightQuerySource,
+	foldQuerySource: assets.foldQuerySource,
+	injectionQuerySource: assets.injectionQuerySource
+});
+var loadTreeSitterLanguageAssets = async (contribution) => {
+	if ("load" in contribution && contribution.load) return contribution.load();
+	return contribution;
+};
+var normalizeOptionalLanguageId = (languageId) => {
+	if (!languageId) return null;
+	const id = languageId.trim();
+	return id.length > 0 ? id : null;
+};
+var normalizeLanguageId = (languageId) => {
+	const id = normalizeOptionalLanguageId(languageId);
+	if (id) return id;
+	throw new Error("Tree-sitter language id cannot be empty");
+};
+var normalizeOptionalAlias = (alias) => {
+	if (!alias) return null;
+	const normalized = alias.trim().toLowerCase();
+	return normalized.length > 0 ? normalized : null;
+};
+var normalizeAlias = (alias) => {
+	const normalized = normalizeOptionalAlias(alias);
+	if (normalized) return normalized;
+	throw new Error("Tree-sitter language alias cannot be empty");
+};
+var normalizeExtension = (extension) => {
+	const normalized = extension.trim().toLowerCase();
+	if (!normalized) throw new Error("Tree-sitter language extension cannot be empty");
+	if (normalized.startsWith(".")) return normalized;
+	return `.${normalized}`;
+};
+var normalizeWasmUrl = (wasmUrl, languageId) => {
+	const normalized = wasmUrl.trim();
+	if (normalized) return normalized;
+	throw new Error(`Tree-sitter language "${languageId}" is missing a wasmUrl`);
+};
+var uniqueItems = (items) => Array.from(new Set(items));
+//#endregion
+export { TreeSitterLanguageRegistry, createTreeSitterLanguageRegistry, isTreeSitterLanguageId, resolveTreeSitterLanguageAlias, resolveTreeSitterLanguageClosure, resolveTreeSitterLanguageContribution, withInjectedLanguages };
+
+//# sourceMappingURL=registry.js.map

package/dist/treeSitter/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/treeSitter/registry.ts"],"sourcesContent":["export type TreeSitterLanguageId = string\n\nexport type TreeSitterLanguageAssets = {\n  readonly wasmUrl: string\n  readonly highlightQuerySource?: string\n  readonly foldQuerySource?: string\n  readonly injectionQuerySource?: string\n}\n\ntype TreeSitterLanguageContributionMetadata = {\n  readonly id: TreeSitterLanguageId\n  readonly extensions?: readonly string[]\n  readonly aliases?: readonly string[]\n  readonly filenames?: readonly string[]\n  readonly injectionDependencies?: readonly string[]\n}\n\ntype TreeSitterInlineLanguageContribution = TreeSitterLanguageContributionMetadata &\n  TreeSitterLanguageAssets & {\n    readonly load?: never\n  }\n\ntype TreeSitterLazyLanguageContribution = TreeSitterLanguageContributionMetadata & {\n  readonly load: () => Promise<TreeSitterLanguageAssets>\n}\n\nexport type TreeSitterLanguageContribution =\n  | TreeSitterInlineLanguageContribution\n  | TreeSitterLazyLanguageContribution\n\nexport type TreeSitterLanguageDescriptor = TreeSitterLanguageContributionMetadata &\n  TreeSitterLanguageAssets & {\n    readonly extensions: readonly string[]\n    readonly aliases: readonly string[]\n  }\n\nexport type TreeSitterLanguageRegistrationOptions = {\n  readonly replace?: boolean\n}\n\nexport type TreeSitterLanguageDisposable = {\n  dispose(): void\n}\n\nexport type TreeSitterLanguageResolver = {\n  resolveTreeSitterLanguage(\n    languageId: TreeSitterLanguageId,\n  ): Promise<TreeSitterLanguageDescriptor | null>\n}\n\ntype TreeSitterLanguageRegistration = {\n  readonly contribution: TreeSitterLanguageContribution\n  readonly id: TreeSitterLanguageId\n  readonly aliases: readonly string[]\n  descriptorPromise: Promise<TreeSitterLanguageDescriptor> | null\n}\n\nexport class TreeSitterLanguageRegistry implements TreeSitterLanguageResolver {\n  private readonly registrations: TreeSitterLanguageRegistration[] = []\n\n  public registerLanguage(\n    contribution: TreeSitterLanguageContribution,\n    options: TreeSitterLanguageRegistrationOptions = {},\n  ): TreeSitterLanguageDisposable {\n    const registration = createRegistration(contribution)\n    this.assertCanRegister(registration.id, options)\n    this.registrations.push(registration)\n\n    return {\n      dispose: () => this.unregisterLanguage(registration),\n    }\n  }\n\n  public hasLanguage(languageId: string | null | undefined): boolean {\n    const id = normalizeOptionalLanguageId(languageId)\n    if (!id) return false\n    return this.activeRegistrationForId(id) !== null\n  }\n\n  public resolveLanguageAlias(alias: string | null | undefined): TreeSitterLanguageId | null {\n    const normalized = normalizeOptionalAlias(alias)\n    if (!normalized) return null\n\n    const registration = this.findActiveRegistration((candidate) => {\n      if (candidate.id.toLowerCase() === normalized) return true\n      return candidate.aliases.includes(normalized)\n    })\n    return registration?.id ?? null\n  }\n\n  public async resolveTreeSitterLanguage(\n    languageId: TreeSitterLanguageId,\n  ): Promise<TreeSitterLanguageDescriptor | null> {\n    const id = this.resolveLanguageAlias(languageId) ?? normalizeLanguageId(languageId)\n    const registration = this.activeRegistrationForId(id)\n    if (!registration) return null\n\n    if (!registration.descriptorPromise) {\n      registration.descriptorPromise = resolveTreeSitterLanguageContribution(\n        registration.contribution,\n      )\n    }\n\n    return registration.descriptorPromise\n  }\n\n  public clear(): void {\n    this.registrations.length = 0\n  }\n\n  private assertCanRegister(\n    languageId: TreeSitterLanguageId,\n    options: TreeSitterLanguageRegistrationOptions,\n  ): void {\n    if (options.replace) return\n    if (!this.hasLanguage(languageId)) return\n\n    throw new Error(`Tree-sitter language \"${languageId}\" is already registered`)\n  }\n\n  private unregisterLanguage(registration: TreeSitterLanguageRegistration): void {\n    const index = this.registrations.indexOf(registration)\n    if (index === -1) return\n\n    this.registrations.splice(index, 1)\n  }\n\n  private findActiveRegistration(\n    predicate: (registration: TreeSitterLanguageRegistration) => boolean,\n  ): TreeSitterLanguageRegistration | null {\n    for (let index = this.registrations.length - 1; index >= 0; index -= 1) {\n      const registration = this.registrations[index]!\n      if (!this.isActiveRegistration(registration)) continue\n      if (predicate(registration)) return registration\n    }\n\n    return null\n  }\n\n  private activeRegistrationForId(\n    languageId: TreeSitterLanguageId,\n  ): TreeSitterLanguageRegistration | null {\n    for (let index = this.registrations.length - 1; index >= 0; index -= 1) {\n      const registration = this.registrations[index]!\n      if (registration.id === languageId) return registration\n    }\n\n    return null\n  }\n\n  private isActiveRegistration(registration: TreeSitterLanguageRegistration): boolean {\n    return this.activeRegistrationForId(registration.id) === registration\n  }\n}\n\nexport const createTreeSitterLanguageRegistry = (): TreeSitterLanguageRegistry =>\n  new TreeSitterLanguageRegistry()\n\nexport const resolveTreeSitterLanguageContribution = async (\n  contribution: TreeSitterLanguageContribution,\n): Promise<TreeSitterLanguageDescriptor> => {\n  const assets = await loadTreeSitterLanguageAssets(contribution)\n  return createTreeSitterLanguageDescriptor(contribution, assets)\n}\n\n/** A language's descriptor followed by every language its injection queries name, transitively. */\nexport const resolveTreeSitterLanguageClosure = async (\n  resolver: TreeSitterLanguageResolver,\n  languageId: TreeSitterLanguageId,\n  isCancelled: () => boolean = () => false,\n): Promise<readonly TreeSitterLanguageDescriptor[]> => {\n  const descriptor = await resolver.resolveTreeSitterLanguage(languageId)\n  if (!descriptor || isCancelled()) return []\n  return withInjectedLanguages(resolver, descriptor, isCancelled)\n}\n\nexport const withInjectedLanguages = async (\n  resolver: TreeSitterLanguageResolver | undefined,\n  descriptor: TreeSitterLanguageDescriptor,\n  isCancelled: () => boolean,\n): Promise<readonly TreeSitterLanguageDescriptor[]> => {\n  const descriptors = [descriptor]\n  const seen = new Set([descriptor.id])\n  for (let index = 0; index < descriptors.length; index += 1) {\n    const dependencies = descriptors[index]?.injectionDependencies ?? []\n    for (const id of dependencies) {\n      if (seen.has(id) || isCancelled()) continue\n      seen.add(id)\n      const injected = await resolver?.resolveTreeSitterLanguage(id)\n      if (injected) descriptors.push(injected)\n    }\n  }\n  return descriptors\n}\n\nexport const resolveTreeSitterLanguageAlias = (\n  alias: string | null | undefined,\n  registry?: TreeSitterLanguageRegistry,\n): TreeSitterLanguageId | null => registry?.resolveLanguageAlias(alias) ?? null\n\nexport const isTreeSitterLanguageId = (\n  languageId: string | null | undefined,\n): languageId is TreeSitterLanguageId => normalizeOptionalLanguageId(languageId) !== null\n\nconst createRegistration = (\n  contribution: TreeSitterLanguageContribution,\n): TreeSitterLanguageRegistration => ({\n  contribution,\n  id: normalizeLanguageId(contribution.id),\n  aliases: uniqueItems((contribution.aliases ?? []).map(normalizeAlias)),\n  descriptorPromise: null,\n})\n\nconst createTreeSitterLanguageDescriptor = (\n  contribution: TreeSitterLanguageContribution,\n  assets: TreeSitterLanguageAssets,\n): TreeSitterLanguageDescriptor => ({\n  id: normalizeLanguageId(contribution.id),\n  extensions: uniqueItems((contribution.extensions ?? []).map(normalizeExtension)),\n  aliases: uniqueItems((contribution.aliases ?? []).map(normalizeAlias)),\n  filenames: contribution.filenames ?? [],\n  injectionDependencies: contribution.injectionDependencies ?? [],\n  wasmUrl: normalizeWasmUrl(assets.wasmUrl, contribution.id),\n  highlightQuerySource: assets.highlightQuerySource,\n  foldQuerySource: assets.foldQuerySource,\n  injectionQuerySource: assets.injectionQuerySource,\n})\n\nconst loadTreeSitterLanguageAssets = async (\n  contribution: TreeSitterLanguageContribution,\n): Promise<TreeSitterLanguageAssets> => {\n  if ('load' in contribution && contribution.load) return contribution.load()\n  return contribution\n}\n\nconst normalizeOptionalLanguageId = (\n  languageId: string | null | undefined,\n): TreeSitterLanguageId | null => {\n  if (!languageId) return null\n\n  const id = languageId.trim()\n  return id.length > 0 ? id : null\n}\n\nconst normalizeLanguageId = (languageId: string): TreeSitterLanguageId => {\n  const id = normalizeOptionalLanguageId(languageId)\n  if (id) return id\n\n  throw new Error('Tree-sitter language id cannot be empty')\n}\n\nconst normalizeOptionalAlias = (alias: string | null | undefined): string | null => {\n  if (!alias) return null\n\n  const normalized = alias.trim().toLowerCase()\n  return normalized.length > 0 ? normalized : null\n}\n\nconst normalizeAlias = (alias: string): string => {\n  const normalized = normalizeOptionalAlias(alias)\n  if (normalized) return normalized\n\n  throw new Error('Tree-sitter language alias cannot be empty')\n}\n\nconst normalizeExtension = (extension: string): string => {\n  const normalized = extension.trim().toLowerCase()\n  if (!normalized) throw new Error('Tree-sitter language extension cannot be empty')\n  if (normalized.startsWith('.')) return normalized\n  return `.${normalized}`\n}\n\nconst normalizeWasmUrl = (wasmUrl: string, languageId: string): string => {\n  const normalized = wasmUrl.trim()\n  if (normalized) return normalized\n\n  throw new Error(`Tree-sitter language \"${languageId}\" is missing a wasmUrl`)\n}\n\nconst uniqueItems = <T>(items: readonly T[]): readonly T[] => Array.from(new Set(items))\n"],"mappings":"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"}

package/dist/treeSitter/source.d.ts

@@ -0,0 +1,42 @@
+import type { PieceTableSnapshot } from '@singapore-editor/core/document';
+type TreeSitterSourcePieceSpan = {
+    readonly chunkId: string;
+    readonly start: number;
+    readonly length: number;
+};
+type TreeSitterSourceChunkPayload = {
+    readonly chunkId: string;
+    readonly text: string;
+};
+export type TreeSitterSourceDescriptor = {
+    readonly length: number;
+    readonly pieces: readonly TreeSitterSourcePieceSpan[];
+    readonly chunks: readonly TreeSitterSourceChunkPayload[];
+};
+export type TreeSitterSourceDescriptorOptions = {
+    readonly sentChunkLengths?: ReadonlyMap<string, number>;
+};
+type ResolvedTreeSitterSourceChunk = {
+    readonly text: string;
+    readonly length: number;
+};
+export type TreeSitterSourceCache = Map<string, Map<string, ResolvedTreeSitterSourceChunk>>;
+type TreeSitterInputChunk = {
+    readonly start: number;
+    readonly end: number;
+    readonly chunkStart: number;
+    readonly source: ResolvedTreeSitterSourceChunk;
+};
+export type TreeSitterPieceTableInput = {
+    readonly length: number;
+    readonly chunks: readonly TreeSitterInputChunk[];
+    lastChunkIndex?: number;
+};
+export declare const createTreeSitterSourceDescriptor: (snapshot: PieceTableSnapshot, options?: TreeSitterSourceDescriptorOptions) => TreeSitterSourceDescriptor;
+export declare const resolveTreeSitterSourceDescriptor: (cache: TreeSitterSourceCache, documentId: string, descriptor: TreeSitterSourceDescriptor) => TreeSitterPieceTableInput;
+export declare const disposeTreeSitterSourceDocument: (cache: TreeSitterSourceCache, documentId: string) => void;
+export declare const clearTreeSitterSourceCache: (cache: TreeSitterSourceCache) => void;
+export declare const readTreeSitterPieceTableInput: (input: TreeSitterPieceTableInput, index: number) => string | undefined;
+export declare const readTreeSitterInputRange: (input: TreeSitterPieceTableInput, startIndex: number, endIndex: number) => string;
+export {};
+//# sourceMappingURL=source.d.ts.map

package/dist/treeSitter/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/treeSitter/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAIzE,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,KAAK,4BAA4B,GAAG;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACrD,QAAQ,CAAC,MAAM,EAAE,SAAS,4BAA4B,EAAE,CAAA;CACzD,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxD,CAAA;AAED,KAAK,6BAA6B,GAAG;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC,CAAA;AAE3F,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,6BAA6B,CAAA;CAC/C,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAQD,eAAO,MAAM,gCAAgC,GAC3C,UAAU,kBAAkB,EAC5B,UAAS,iCAAsC,KAC9C,0BAoBF,CAAA;AAED,eAAO,MAAM,iCAAiC,GAC5C,OAAO,qBAAqB,EAC5B,YAAY,MAAM,EAClB,YAAY,0BAA0B,KACrC,yBASF,CAAA;AAED,eAAO,MAAM,+BAA+B,GAC1C,OAAO,qBAAqB,EAC5B,YAAY,MAAM,KACjB,IAEF,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,OAAO,qBAAqB,KAAG,IAEzE,CAAA;AAED,eAAO,MAAM,6BAA6B,GACxC,OAAO,yBAAyB,EAChC,OAAO,MAAM,KACZ,MAAM,GAAG,SAeX,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,yBAAyB,EAChC,YAAY,MAAM,EAClB,UAAU,MAAM,KACf,MAgBF,CAAA"}

package/dist/treeSitter/source.js

@@ -0,0 +1,175 @@
+import { debugPieceTable, forEachBufferSpan } from "@singapore-editor/core/debug";
+//#region src/treeSitter/source.ts
+var SOURCE_CHUNK_SIZE = 16384;
+var PARSER_READ_BATCH_CODE_UNITS = 4096;
+var sourceOwners = /* @__PURE__ */ new WeakMap();
+var nextSourceOwner = 1;
+var createTreeSitterSourceDescriptor = (snapshot, options = {}) => {
+	const pieces = [];
+	const chunks = [];
+	const emittedChunkIds = /* @__PURE__ */ new Set();
+	for (const piece of debugPieceTable(snapshot)) {
+		if (!piece.visible) continue;
+		appendPieceSpans(snapshot, piece.buffer, piece.start, piece.length, {
+			pieces,
+			chunks,
+			emittedChunkIds,
+			sentChunkLengths: options.sentChunkLengths
+		});
+	}
+	return {
+		length: snapshot.length,
+		pieces,
+		chunks
+	};
+};
+var resolveTreeSitterSourceDescriptor = (cache, documentId, descriptor) => {
+	const documentCache = ensureDocumentSourceCache(cache, documentId);
+	const chunks = resolveDescriptorChunks(documentCache, descriptor);
+	keepReferencedChunks(documentCache, descriptor);
+	return {
+		length: descriptor.length,
+		chunks
+	};
+};
+var readTreeSitterPieceTableInput = (input, index) => {
+	if (index < 0 || index >= input.length) return void 0;
+	const chunk = findChunkContainingWithCursor(input, index);
+	if (!chunk) return void 0;
+	const sourceStart = chunk.chunkStart + index - chunk.start;
+	const sourceEnd = chunk.chunkStart + chunk.end - chunk.start;
+	const readEnd = safeParserReadEnd(chunk.source, sourceStart, Math.min(sourceEnd, sourceStart + PARSER_READ_BATCH_CODE_UNITS), sourceEnd);
+	return readResolvedChunkText(chunk.source, sourceStart, readEnd);
+};
+var readTreeSitterInputRange = (input, startIndex, endIndex) => {
+	if (endIndex <= startIndex) return "";
+	const chunks = [];
+	for (const chunk of input.chunks) {
+		if (chunk.end <= startIndex) continue;
+		if (chunk.start >= endIndex) break;
+		const start = Math.max(startIndex, chunk.start) - chunk.start;
+		const end = Math.min(endIndex, chunk.end) - chunk.start;
+		chunks.push(readResolvedChunkText(chunk.source, chunk.chunkStart + start, chunk.chunkStart + end));
+	}
+	return chunks.join("");
+};
+var appendPieceSpans = (snapshot, bufferId, start, length, builder) => {
+	forEachBufferSpan(snapshot.buffers, bufferId, start, start + length, (text, from, to, owner) => {
+		appendSourceSpans(text, owner, from, to, builder);
+	});
+};
+var appendSourceSpans = (text, owner, start, end, builder) => {
+	let offset = start;
+	while (offset < end) {
+		const chunkStart = Math.floor(offset / SOURCE_CHUNK_SIZE) * SOURCE_CHUNK_SIZE;
+		const chunkLength = Math.min(text.length - chunkStart, SOURCE_CHUNK_SIZE);
+		const spanStart = offset - chunkStart;
+		const spanLength = Math.min(end - offset, chunkLength - spanStart);
+		const chunkId = sourceChunkId(owner, chunkStart);
+		builder.pieces.push({
+			chunkId,
+			start: spanStart,
+			length: spanLength
+		});
+		appendChunkPayload(text, chunkId, chunkStart, chunkLength, builder);
+		offset += spanLength;
+	}
+};
+var appendChunkPayload = (text, chunkId, chunkStart, chunkLength, builder) => {
+	if (builder.sentChunkLengths?.get(chunkId) === chunkLength) return;
+	if (builder.emittedChunkIds.has(chunkId)) return;
+	builder.emittedChunkIds.add(chunkId);
+	builder.chunks.push({
+		chunkId,
+		text: text.slice(chunkStart, chunkStart + chunkLength)
+	});
+};
+var sourceChunkId = (owner, chunkStart) => {
+	let id = sourceOwners.get(owner);
+	if (id === void 0) {
+		id = nextSourceOwner++;
+		sourceOwners.set(owner, id);
+	}
+	return `${id}:${chunkStart}`;
+};
+var ensureDocumentSourceCache = (cache, documentId) => {
+	const existing = cache.get(documentId);
+	if (existing) return existing;
+	const documentCache = /* @__PURE__ */ new Map();
+	cache.set(documentId, documentCache);
+	return documentCache;
+};
+var resolveDescriptorChunks = (cache, descriptor) => {
+	cacheChunkPayloads(cache, descriptor.chunks);
+	const chunks = [];
+	let documentOffset = 0;
+	for (const piece of descriptor.pieces) {
+		const source = cache.get(piece.chunkId);
+		if (!source) throw new Error(`Tree-sitter source chunk "${piece.chunkId}" is missing`);
+		chunks.push({
+			start: documentOffset,
+			end: documentOffset + piece.length,
+			chunkStart: piece.start,
+			source
+		});
+		documentOffset += piece.length;
+	}
+	if (documentOffset !== descriptor.length) throw new Error("Tree-sitter source length mismatch");
+	return chunks;
+};
+var keepReferencedChunks = (cache, descriptor) => {
+	const referenced = new Set(descriptor.pieces.map((piece) => piece.chunkId));
+	for (const chunkId of cache.keys()) if (!referenced.has(chunkId)) cache.delete(chunkId);
+};
+var cacheChunkPayloads = (cache, chunks) => {
+	for (const chunk of chunks) cache.set(chunk.chunkId, {
+		text: chunk.text,
+		length: chunk.text.length
+	});
+};
+var readResolvedChunkText = (chunk, start, end) => chunk.text.slice(start, end);
+var safeParserReadEnd = (chunk, start, end, maxEnd) => {
+	if (end >= maxEnd || end <= start) return end;
+	if (!isHighSurrogate(readResolvedChunkCodeUnit(chunk, end - 1))) return end;
+	return Math.max(start + 1, end - 1);
+};
+var readResolvedChunkCodeUnit = (chunk, index) => chunk.text.charCodeAt(index);
+var isHighSurrogate = (codeUnit) => codeUnit >= 55296 && codeUnit <= 56319;
+var findChunkContaining = (chunks, index) => {
+	let low = 0;
+	let high = chunks.length - 1;
+	while (low <= high) {
+		const middle = Math.floor((low + high) / 2);
+		const chunk = chunks[middle];
+		if (!chunk) return null;
+		if (index < chunk.start) {
+			high = middle - 1;
+			continue;
+		}
+		if (index >= chunk.end) {
+			low = middle + 1;
+			continue;
+		}
+		return chunk;
+	}
+	return null;
+};
+var findChunkContainingWithCursor = (input, index) => {
+	const cachedIndex = input.lastChunkIndex;
+	const cached = cachedIndex === void 0 ? null : input.chunks[cachedIndex];
+	if (cached && index >= cached.start && index < cached.end) return cached;
+	if (cachedIndex !== void 0) {
+		const next = input.chunks[cachedIndex + 1];
+		if (next && index >= next.start && index < next.end) {
+			input.lastChunkIndex = cachedIndex + 1;
+			return next;
+		}
+	}
+	const chunk = findChunkContaining(input.chunks, index);
+	if (chunk) input.lastChunkIndex = input.chunks.indexOf(chunk);
+	return chunk;
+};
+//#endregion
+export { createTreeSitterSourceDescriptor, readTreeSitterInputRange, readTreeSitterPieceTableInput, resolveTreeSitterSourceDescriptor };
+
+//# sourceMappingURL=source.js.map