@alex-dbs/coderuler 0.0.0-stage → 1.3.0

package/dist/adapter/scope/astgrep.js

@@ -0,0 +1,183 @@
+import { parse } from '@ast-grep/napi';
+import { resolveAstGrepLanguage } from './astgrep-languages.js';
+import { textLineSpan } from './lines.js';
+const METAVARIABLE = /\$\$\$([A-Za-z_][A-Za-z0-9_]*)|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+const ANONYMOUS = /^_+$/;
+function isMapping(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function optionalMapping(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!isMapping(value))
+        throw new Error(`ast-grep scope option ${name} must be a mapping`);
+    return value;
+}
+function addPatternCaptures(pattern, specs) {
+    for (const match of pattern.matchAll(METAVARIABLE)) {
+        const multiple = match[1] !== undefined;
+        const name = multiple ? match[1] : match[2];
+        if (ANONYMOUS.test(name))
+            continue;
+        if (multiple || !specs.has(name))
+            specs.set(name, multiple);
+    }
+}
+function collectCaptureSpecs(value, specs) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectCaptureSpecs(item, specs);
+        return;
+    }
+    if (!isMapping(value))
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'pattern') {
+            if (typeof child === 'string')
+                addPatternCaptures(child, specs);
+            else if (isMapping(child) && typeof child.context === 'string')
+                addPatternCaptures(child.context, specs);
+            continue;
+        }
+        collectCaptureSpecs(child, specs);
+    }
+}
+function readCaptures(node, specs) {
+    const captures = {};
+    for (const spec of specs) {
+        if (spec.multiple) {
+            const nodes = node.getMultipleMatches(spec.name);
+            if (nodes.length > 0)
+                captures[spec.name] = nodes.map((child) => child.text());
+        }
+        else {
+            const match = node.getMatch(spec.name);
+            if (match !== null)
+                captures[spec.name] = match.text();
+        }
+    }
+    return captures;
+}
+function firstDescendantText(node, kind) {
+    for (const child of node.namedChildren()) {
+        if (child.kind() === kind)
+            return child.text();
+        const nested = firstDescendantText(child, kind);
+        if (nested !== null)
+            return nested;
+    }
+    return null;
+}
+function receiverTypeName(method) {
+    const receiver = method.field('receiver');
+    return receiver === null ? null : firstDescendantText(receiver, 'type_identifier');
+}
+function declarationSegment(node) {
+    const nameNode = node.field('name');
+    if (nameNode === null)
+        return null;
+    const name = nameNode.text();
+    if (name === '')
+        return null;
+    const kind = node.kind();
+    if (kind !== 'method_declaration')
+        return `${kind}:${name}`;
+    const receiver = receiverTypeName(node);
+    return receiver === null ? `${kind}:${name}` : `${kind}:${receiver}.${name}`;
+}
+function identityOf(node, occurrence) {
+    const own = declarationSegment(node);
+    if (own === null)
+        return `${node.kind()}#${occurrence}`;
+    const enclosing = [];
+    let ancestor = node.parent();
+    while (ancestor !== null) {
+        const segment = declarationSegment(ancestor);
+        if (segment !== null)
+            enclosing.unshift(segment);
+        const parent = ancestor.parent();
+        if (parent === null || parent.id() === ancestor.id())
+            break;
+        ancestor = parent;
+    }
+    return [...enclosing, own].join('/');
+}
+function uniqueIds(bases) {
+    const taken = new Set(bases);
+    const nextSuffix = new Map();
+    const ids = [];
+    for (const base of bases) {
+        const suffixFrom = nextSuffix.get(base);
+        if (suffixFrom === undefined) {
+            nextSuffix.set(base, 1);
+            ids.push(base);
+            continue;
+        }
+        let suffix = suffixFrom;
+        while (taken.has(`${base}#${suffix}`))
+            suffix += 1;
+        const id = `${base}#${suffix}`;
+        nextSuffix.set(base, suffix + 1);
+        taken.add(id);
+        ids.push(id);
+    }
+    return ids;
+}
+function compileQuery(language, raw, prefix = '') {
+    const rule = raw.rule;
+    if (!isMapping(rule))
+        throw new Error(`ast-grep scope option ${prefix}rule must be a mapping`);
+    const constraints = optionalMapping(raw.constraints, `${prefix}constraints`);
+    const utils = optionalMapping(raw.utils, `${prefix}utils`);
+    const config = { rule };
+    if (constraints !== undefined)
+        config.constraints = constraints;
+    if (utils !== undefined)
+        config.utils = utils;
+    const nativeConfig = config;
+    parse(language, '').root().findAll(nativeConfig);
+    const specs = new Map();
+    collectCaptureSpecs([rule, constraints, utils], specs);
+    const captureSpecs = [...specs].map(([name, multiple]) => ({ name, multiple }));
+    return { nativeConfig, captureSpecs };
+}
+export function astGrep(options) {
+    const raw = options;
+    const language = raw.language;
+    if (typeof language !== 'string' || language === '') {
+        throw new Error('ast-grep scope option language must be a non-empty string');
+    }
+    const nativeLanguage = resolveAstGrepLanguage(language);
+    const tsxOptions = optionalMapping(raw.tsx, 'tsx');
+    if (tsxOptions !== undefined && nativeLanguage !== 'typescript') {
+        throw new Error('ast-grep scope option tsx is only supported for TypeScript');
+    }
+    const query = compileQuery(nativeLanguage, raw);
+    const tsxQuery = tsxOptions === undefined ? query : compileQuery('tsx', tsxOptions, 'tsx.');
+    if (nativeLanguage === 'typescript' && tsxOptions === undefined) {
+        parse('tsx', '').root().findAll(query.nativeConfig);
+    }
+    return (file) => {
+        const useTsx = nativeLanguage === 'typescript' && file.filepath.endsWith('.tsx');
+        const selected = useTsx ? tsxQuery : query;
+        const matches = parse(useTsx ? 'tsx' : nativeLanguage, file.source).root().findAll(selected.nativeConfig);
+        const occurrences = new Map();
+        const bases = [];
+        for (const node of matches) {
+            const kind = node.kind();
+            const occurrence = occurrences.get(kind) ?? 0;
+            occurrences.set(kind, occurrence + 1);
+            bases.push(identityOf(node, occurrence));
+        }
+        const ids = uniqueIds(bases);
+        return matches.map((node, index) => {
+            const text = node.text();
+            return {
+                id: ids[index],
+                source: text,
+                captures: readCaptures(node, selected.captureSpecs),
+                lines: textLineSpan(node.range().start.line + 1, text),
+            };
+        });
+    };
+}

package/dist/adapter/scope/csv.d.ts

@@ -0,0 +1,4 @@
+import type { CsvOptions, CsvRow } from '../../app/ports.js';
+import type { ScopeSelector } from '../../app/rule.js';
+export declare function parseCsv(source: string, options?: CsvOptions): readonly CsvRow[];
+export declare function csv(options?: CsvOptions): ScopeSelector<CsvRow>;

package/dist/adapter/scope/csv.js

@@ -0,0 +1,158 @@
+import { parse } from 'csv-parse/sync';
+import { textLineSpan } from './lines.js';
+const LEADING_BREAKS = /^(?:\r\n|\r|\n)+/;
+const TRAILING_BREAK = /(?:\r\n|\r|\n)$/;
+const LINE_BREAKS = /\r\n|\r|\n/g;
+function isSingleCodePoint(value) {
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && value.length === (codePoint > 0xffff ? 2 : 1);
+}
+function resolveOptions(options) {
+    const headers = options?.headers === undefined ? true : options.headers;
+    if (typeof headers !== 'boolean')
+        throw new Error('The CSV "headers" option must be a boolean');
+    const delimiter = options?.delimiter === undefined ? ',' : options.delimiter;
+    if (typeof delimiter !== 'string'
+        || !isSingleCodePoint(delimiter)
+        || delimiter === '"'
+        || delimiter === '\r'
+        || delimiter === '\n') {
+        throw new Error('The CSV "delimiter" must be a single character other than CR, LF, or a quote');
+    }
+    const key = options?.key;
+    if (key !== undefined) {
+        if (typeof key !== 'string' || key === '')
+            throw new Error('The CSV "key" must be a non-empty string');
+        if (!headers)
+            throw new Error('The CSV "key" option requires headers');
+    }
+    return { headers, delimiter, key };
+}
+function parseRecords(source, delimiter) {
+    let parsed;
+    try {
+        parsed = parse(source, {
+            bom: true,
+            cast: false,
+            delimiter,
+            info: true,
+            relax_column_count: false,
+            skip_empty_lines: true,
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`CSV source could not be parsed: ${reason}`);
+    }
+    if (!Array.isArray(parsed))
+        throw new Error('CSV source could not be parsed: unexpected parser output');
+    return parsed.map((entry) => {
+        const candidate = entry;
+        if (candidate === null || typeof candidate !== 'object') {
+            throw new Error('CSV source could not be parsed: unexpected record shape');
+        }
+        const record = 'record' in candidate ? candidate.record : undefined;
+        const info = 'info' in candidate ? candidate.info : undefined;
+        const endByte = info !== null && typeof info === 'object' && 'bytes' in info ? info.bytes : undefined;
+        if (!Array.isArray(record)
+            || typeof endByte !== 'number'
+            || !Number.isInteger(endByte)
+            || endByte < 0) {
+            throw new Error('CSV source could not be parsed: unexpected record shape');
+        }
+        return { record, endByte };
+    });
+}
+function locateRecords(source, records) {
+    const located = [];
+    let charIndex = 0;
+    let byteIndex = 0;
+    let sliceStart = 0;
+    let startLine = 1;
+    for (const record of records) {
+        while (byteIndex < record.endByte) {
+            const codePoint = source.codePointAt(charIndex);
+            if (codePoint === undefined) {
+                throw new Error('CSV source could not be parsed: record offset exceeds the source');
+            }
+            byteIndex += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
+            charIndex += codePoint > 0xffff ? 2 : 1;
+        }
+        let sliced = source.slice(sliceStart, charIndex);
+        if (sliceStart === 0 && sliced.charCodeAt(0) === 0xfeff)
+            sliced = sliced.slice(1);
+        sliceStart = charIndex;
+        const leading = sliced.match(LEADING_BREAKS)?.[0] ?? '';
+        startLine += leading.match(LINE_BREAKS)?.length ?? 0;
+        const text = sliced.slice(leading.length).replace(TRAILING_BREAK, '');
+        located.push({ fields: record.record, source: text, lines: textLineSpan(startLine, text) });
+        startLine += (text.match(LINE_BREAKS)?.length ?? 0) + 1;
+    }
+    return located;
+}
+function headerNames(located) {
+    if (located === undefined)
+        return [];
+    const names = new Set();
+    for (const name of located.fields) {
+        if (name === '')
+            throw new Error('CSV header names must be nonempty');
+        if (names.has(name))
+            throw new Error(`CSV header names must be unique but "${name}" appears twice`);
+        names.add(name);
+    }
+    return located.fields;
+}
+function toRecord(header, fields) {
+    const record = {};
+    header.forEach((name, index) => {
+        const value = fields[index];
+        if (value === undefined)
+            throw new Error('CSV record has fewer fields than its header');
+        Object.defineProperty(record, name, { value, enumerable: true, writable: true, configurable: true });
+    });
+    return record;
+}
+function rowsOf(located, options) {
+    if (!options.headers)
+        return located.map(record => record.fields);
+    const header = headerNames(located[0]);
+    return located.slice(1).map(record => toRecord(header, record.fields));
+}
+export function parseCsv(source, options) {
+    const resolved = resolveOptions(options);
+    return rowsOf(locateRecords(source, parseRecords(source, resolved.delimiter)), resolved);
+}
+function selectScopes(source, options) {
+    const located = locateRecords(source, parseRecords(source, options.delimiter));
+    if (!options.headers) {
+        return located.map((record, index) => ({
+            id: `row:${index + 1}`,
+            source: record.source,
+            data: record.fields,
+            lines: record.lines,
+        }));
+    }
+    const header = headerNames(located[0]);
+    const column = options.key;
+    if (column !== undefined && !header.includes(column)) {
+        throw new Error(`The CSV key column "${column}" is not present in the header`);
+    }
+    const ids = new Set();
+    return located.slice(1).map((record, index) => {
+        const data = toRecord(header, record.fields);
+        const key = column === undefined ? undefined : data[column];
+        if (column !== undefined && (key === undefined || key === '')) {
+            throw new Error(`The CSV key column "${column}" is blank in data row ${index + 1}`);
+        }
+        const id = key ?? `row:${index + 1}`;
+        if (ids.has(id))
+            throw new Error(`CSV scope ids must be unique but "${id}" appears twice`);
+        ids.add(id);
+        return { id, source: record.source, data, lines: record.lines };
+    });
+}
+export function csv(options) {
+    const resolved = resolveOptions(options);
+    return ({ source }) => selectScopes(source, resolved);
+}

package/dist/adapter/scope/file.d.ts

@@ -0,0 +1,2 @@
+import type { ScopeSelector } from '../../app/rule.js';
+export declare function file(): ScopeSelector<never>;

package/dist/adapter/scope/file.js

@@ -0,0 +1,4 @@
+import { wholeFileScope } from '../../app/selection.js';
+export function file() {
+    return wholeFileScope;
+}

package/dist/adapter/scope/json.d.ts

@@ -0,0 +1,7 @@
+import type { JsonValue, ScopeSelector } from '../../app/rule.js';
+export interface JsonScopeOptions {
+    readonly path?: string;
+    readonly key?: string;
+}
+export declare function parseJson(source: string): JsonValue;
+export declare function json<T = JsonValue>(options?: JsonScopeOptions): ScopeSelector<T>;

package/dist/adapter/scope/json.js

@@ -0,0 +1,132 @@
+import { parseTree, printParseErrorCode } from 'jsonc-parser';
+import { SourceLines } from './lines.js';
+import { keyOf, pointerSegments, query, validatePath } from './structured.js';
+const PARSE_OPTIONS = { disallowComments: true, allowTrailingComma: false, allowEmptyContent: false };
+function memberOf(property) {
+    if (property.type !== 'property')
+        return undefined;
+    const pair = property.children ?? [];
+    const key = pair[0];
+    const value = pair[1];
+    if (key === undefined || value === undefined || pair.length !== 2)
+        return undefined;
+    return { name: String(key.value), value };
+}
+function propertyValue(node, name) {
+    for (const property of node.children ?? []) {
+        const member = memberOf(property);
+        if (member !== undefined && member.name === name)
+            return member.value;
+    }
+    return undefined;
+}
+function objectValue(node) {
+    const result = {};
+    const names = new Set();
+    for (const property of node.children ?? []) {
+        const member = memberOf(property);
+        if (member === undefined)
+            throw new Error('JSON source contains an invalid object member');
+        if (names.has(member.name)) {
+            throw new Error(`JSON source contains a duplicate object key "${member.name}"`);
+        }
+        names.add(member.name);
+        Object.defineProperty(result, member.name, {
+            value: nodeValue(member.value),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return result;
+}
+function nodeValue(node) {
+    switch (node.type) {
+        case 'object':
+            return objectValue(node);
+        case 'array':
+            return (node.children ?? []).map(nodeValue);
+        case 'null':
+            return null;
+        case 'boolean':
+            return node.value === true;
+        case 'number': {
+            const value = node.value;
+            if (!Number.isFinite(value))
+                throw new Error('JSON source contains a non-finite number');
+            return value;
+        }
+        case 'string':
+            return node.value;
+        default:
+            throw new Error('JSON source contains an unsupported value');
+    }
+}
+function parseDocument(source) {
+    const errors = [];
+    const root = parseTree(source, errors, PARSE_OPTIONS);
+    const first = errors[0];
+    if (root === undefined || first !== undefined) {
+        const problem = first === undefined
+            ? 'no JSON content'
+            : `${printParseErrorCode(first.error)} at offset ${first.offset}`;
+        throw new Error(`JSON source could not be parsed: ${problem}`);
+    }
+    return { data: nodeValue(root), root };
+}
+export function parseJson(source) {
+    return parseDocument(source).data;
+}
+function nodeAt(root, segments) {
+    let node = root;
+    for (const segment of segments) {
+        if (node.type === 'object') {
+            const member = propertyValue(node, segment);
+            if (member === undefined)
+                throw new Error(`The JSON pointer segment "${segment}" does not exist`);
+            node = member;
+            continue;
+        }
+        if (node.type === 'array') {
+            const index = Number(segment);
+            const member = Number.isInteger(index) && index >= 0 ? (node.children ?? [])[index] : undefined;
+            if (member === undefined)
+                throw new Error(`The JSON pointer segment "${segment}" does not exist`);
+            node = member;
+            continue;
+        }
+        throw new Error(`The JSON pointer segment "${segment}" does not exist`);
+    }
+    return node;
+}
+function selectScopes(source, selector, keySelector) {
+    const document = parseDocument(source);
+    const lines = new SourceLines(source);
+    const matches = selector.trim() === '$'
+        ? [{ pointer: '', value: document.data }]
+        : query(document.data, selector);
+    return matches.map((match) => {
+        const node = nodeAt(document.root, pointerSegments(match.pointer));
+        const start = node.offset;
+        const end = node.offset + node.length;
+        return {
+            id: keySelector === undefined ? (match.pointer === '' ? '$' : match.pointer) : keyOf(match.value, keySelector),
+            source: source.slice(start, end),
+            data: match.value,
+            lines: lines.span(start, end),
+        };
+    });
+}
+export function json(options) {
+    const selector = options?.path === undefined ? '$' : options.path;
+    if (typeof selector !== 'string')
+        throw new Error('The JSON scope "path" must be a non-empty string');
+    validatePath(selector, 'JSON scope path');
+    const keySelector = options?.key;
+    if (keySelector !== undefined && typeof keySelector !== 'string') {
+        throw new Error('The JSON scope "key" must be a non-empty string');
+    }
+    if (keySelector !== undefined)
+        validatePath(keySelector, 'JSON scope key');
+    return ({ source }) => selectScopes(source, selector, keySelector);
+}

package/dist/adapter/scope/lines.d.ts

@@ -0,0 +1,10 @@
+export interface LineSpan {
+    readonly start: number;
+    readonly end: number;
+}
+export declare function textLineSpan(startLine: number, text: string): LineSpan;
+export declare class SourceLines {
+    #private;
+    constructor(source: string);
+    span(start: number, end: number): LineSpan;
+}

package/dist/adapter/scope/lines.js

@@ -0,0 +1,42 @@
+const TRAILING_LINE_BREAKS = /(?:\r\n|\r|\n)$/;
+const LINE_BREAKS = /\r\n|[\r\n]/g;
+export function textLineSpan(startLine, text) {
+    const breaks = text.replace(TRAILING_LINE_BREAKS, '').match(LINE_BREAKS);
+    return { start: startLine, end: startLine + (breaks === null ? 0 : breaks.length) };
+}
+export class SourceLines {
+    #starts;
+    constructor(source) {
+        const starts = [0];
+        for (let index = 0; index < source.length; index += 1) {
+            const code = source.charCodeAt(index);
+            if (code === 10)
+                starts.push(index + 1);
+            else if (code === 13) {
+                if (source.charCodeAt(index + 1) === 10)
+                    index += 1;
+                starts.push(index + 1);
+            }
+        }
+        this.#starts = starts;
+    }
+    span(start, end) {
+        const first = this.#lineAt(start);
+        if (end <= start)
+            return { start: first, end: first };
+        return { start: first, end: this.#lineAt(end - 1) };
+    }
+    #lineAt(offset) {
+        const starts = this.#starts;
+        let low = 0;
+        let high = starts.length - 1;
+        while (low < high) {
+            const middle = (low + high + 1) >> 1;
+            if (starts[middle] <= offset)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        return low + 1;
+    }
+}

package/dist/adapter/scope/protobuf-options.d.ts

@@ -0,0 +1,29 @@
+import type { JsonValue } from '../../app/rule.js';
+export type ProtoSpan = {
+    readonly start: number;
+    readonly end: number;
+};
+export type OptionScalar = {
+    readonly kind: 'scalar';
+    readonly value: string | number | boolean;
+    readonly span: ProtoSpan;
+};
+export type OptionMessage = {
+    readonly kind: 'message';
+    readonly fields: Map<string, OptionField>;
+    span?: ProtoSpan;
+};
+export type OptionNode = OptionScalar | OptionMessage;
+type OptionField = {
+    readonly values: OptionNode[];
+    repeated: boolean;
+    span: ProtoSpan;
+};
+export declare function optionMessage(span?: ProtoSpan): OptionMessage;
+export declare function extendSpan(current: ProtoSpan | undefined, next: ProtoSpan): ProtoSpan;
+export declare function addOptionField(message: OptionMessage, key: string, values: readonly OptionNode[], span: ProtoSpan, list: boolean): void;
+export declare function assignOption(root: OptionMessage, path: readonly string[], values: readonly OptionNode[], valueSpan: ProtoSpan, list: boolean, entrySpan: ProtoSpan): void;
+export declare function optionsJson(message: OptionMessage, pointer: string, spans: Map<string, ProtoSpan>): {
+    readonly [key: string]: JsonValue;
+};
+export {};

package/dist/adapter/scope/protobuf-options.js

@@ -0,0 +1,64 @@
+import { pointerSegment } from './structured.js';
+export function optionMessage(span) {
+    return span === undefined ? { kind: 'message', fields: new Map() } : { kind: 'message', fields: new Map(), span };
+}
+export function extendSpan(current, next) {
+    return current === undefined
+        ? next
+        : { start: Math.min(current.start, next.start), end: Math.max(current.end, next.end) };
+}
+export function addOptionField(message, key, values, span, list) {
+    const field = message.fields.get(key);
+    if (field === undefined) {
+        message.fields.set(key, { values: [...values], repeated: list, span });
+        return;
+    }
+    field.values.push(...values);
+    field.repeated = true;
+    field.span = extendSpan(field.span, span);
+}
+export function assignOption(root, path, values, valueSpan, list, entrySpan) {
+    root.span = extendSpan(root.span, entrySpan);
+    let current = root;
+    for (let index = 0; index < path.length - 1; index += 1) {
+        const segment = path[index];
+        const field = current.fields.get(segment);
+        if (field === undefined) {
+            const child = optionMessage(entrySpan);
+            current.fields.set(segment, { values: [child], repeated: false, span: entrySpan });
+            current = child;
+            continue;
+        }
+        const child = field.values[0];
+        if (field.repeated || field.values.length !== 1 || child?.kind !== 'message') {
+            throw new Error(`Option "${path.join('.')}" sets a field inside a non-message value`);
+        }
+        child.span = extendSpan(child.span, entrySpan);
+        current = child;
+    }
+    addOptionField(current, path[path.length - 1], values, valueSpan, list);
+}
+export function optionsJson(message, pointer, spans) {
+    if (message.span !== undefined)
+        spans.set(pointer, message.span);
+    const result = {};
+    for (const [key, field] of message.fields) {
+        const childPointer = `${pointer}/${pointerSegment(key)}`;
+        if (field.repeated) {
+            spans.set(childPointer, field.span);
+            const values = field.values.map((value, index) => nodeJson(value, `${childPointer}/${index}`, spans));
+            Object.defineProperty(result, key, { value: values, enumerable: true, writable: true, configurable: true });
+        }
+        else {
+            Object.defineProperty(result, key, { value: nodeJson(field.values[0], childPointer, spans), enumerable: true, writable: true, configurable: true });
+        }
+    }
+    return result;
+}
+function nodeJson(node, pointer, spans) {
+    if (node.kind === 'scalar') {
+        spans.set(pointer, node.span);
+        return node.value;
+    }
+    return optionsJson(node, pointer, spans);
+}

package/dist/adapter/scope/protobuf-parser.d.ts

@@ -0,0 +1,30 @@
+import type { JsonValue } from '../../app/rule.js';
+import { type ProtoSpan } from './protobuf-options.js';
+export declare const DECLARATION_LISTS: readonly ['services', 'rpcs', 'messages', 'fields', 'oneofs', 'enums', 'enumValues', 'extensions'];
+export type DeclarationList = (typeof DECLARATION_LISTS)[number];
+export type ProtoDeclaration = {
+    readonly id: string;
+    readonly name: string;
+    readonly parent: string | null;
+    readonly options: {
+        readonly [key: string]: JsonValue;
+    };
+};
+export type ProtoDocument = {
+    readonly options: {
+        readonly [key: string]: JsonValue;
+    };
+    readonly services: readonly ProtoDeclaration[];
+    readonly rpcs: readonly ProtoDeclaration[];
+    readonly messages: readonly ProtoDeclaration[];
+    readonly fields: readonly ProtoDeclaration[];
+    readonly oneofs: readonly ProtoDeclaration[];
+    readonly enums: readonly ProtoDeclaration[];
+    readonly enumValues: readonly ProtoDeclaration[];
+    readonly extensions: readonly ProtoDeclaration[];
+};
+export type ProtoFile = {
+    readonly data: ProtoDocument;
+    readonly spans: ReadonlyMap<string, ProtoSpan>;
+};
+export declare function readProtoFile(source: string): ProtoFile;