@mcamdali/sdkbump 0.0.0-stage → 0.1.3

package/dist/collect/pbxproj.js

@@ -0,0 +1,260 @@
+// Reads the app targets of an Xcode project from project.pbxproj (an old-style "OpenStep"
+// property list): their names, product types and the build settings that decide which Info.plist
+// they use and which platform they build for.
+import { dirname, join, resolve } from 'node:path';
+import { NOT_READ, readProjectFile } from '../core/files.js';
+export class XcodeProjectError extends Error {
+    name = 'XcodeProjectError';
+}
+/** Parses an old-style property list such as project.pbxproj. */
+export function parseOpenStep(text) {
+    let index = 0;
+    const fail = (message) => {
+        const line = text.slice(0, index).split('\n').length;
+        throw new XcodeProjectError(`${message} (line ${line})`);
+    };
+    const skip = () => {
+        for (;;) {
+            const char = text[index];
+            if (char === undefined)
+                return;
+            if (/\s/.test(char))
+                index++;
+            else if (text.startsWith('//', index)) {
+                const end = text.indexOf('\n', index);
+                index = end === -1 ? text.length : end + 1;
+            }
+            else if (text.startsWith('/*', index)) {
+                const end = text.indexOf('*/', index + 2);
+                if (end === -1)
+                    fail('Unclosed comment');
+                index = end + 2;
+            }
+            else
+                return;
+        }
+    };
+    const quoted = () => {
+        index++;
+        let result = '';
+        for (;;) {
+            const char = text[index++];
+            if (char === undefined)
+                fail('Unclosed string');
+            if (char === '"')
+                return result;
+            if (char !== '\\') {
+                result += char;
+                continue;
+            }
+            const escaped = text[index++];
+            if (escaped === 'n')
+                result += '\n';
+            else if (escaped === 't')
+                result += '\t';
+            else if (escaped === 'r')
+                result += '\r';
+            else if (escaped === 'U' || escaped === 'u') {
+                const hex = text.slice(index, index + 4);
+                if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                    fail('Bad unicode escape');
+                result += String.fromCharCode(Number.parseInt(hex, 16));
+                index += 4;
+            }
+            else if (escaped !== undefined)
+                result += escaped;
+        }
+    };
+    const bare = () => {
+        const match = /^[A-Za-z0-9_$+./:-]+/.exec(text.slice(index, index + 4096));
+        if (!match)
+            return fail(`Unexpected character "${text[index] ?? 'end of file'}"`);
+        index += match[0].length;
+        return match[0];
+    };
+    const value = () => {
+        skip();
+        const char = text[index];
+        if (char === '{') {
+            index++;
+            const dict = {};
+            for (;;) {
+                skip();
+                if (text[index] === '}') {
+                    index++;
+                    return dict;
+                }
+                const key = text[index] === '"' ? quoted() : bare();
+                skip();
+                if (text[index] !== '=')
+                    fail('Expected "="');
+                index++;
+                dict[key] = value();
+                skip();
+                if (text[index] !== ';')
+                    fail('Expected ";"');
+                index++;
+            }
+        }
+        if (char === '(') {
+            index++;
+            const array = [];
+            for (;;) {
+                skip();
+                if (text[index] === ')') {
+                    index++;
+                    return array;
+                }
+                array.push(value());
+                skip();
+                if (text[index] === ',')
+                    index++;
+                else if (text[index] !== ')')
+                    fail('Expected "," or ")"');
+            }
+        }
+        if (char === '"')
+            return quoted();
+        if (char === '<') {
+            const end = text.indexOf('>', index);
+            if (end === -1)
+                fail('Unclosed data');
+            const data = text.slice(index + 1, end).replace(/\s+/g, '');
+            index = end + 1;
+            return data;
+        }
+        return bare();
+    };
+    const result = value();
+    skip();
+    if (index < text.length)
+        fail('Unexpected text after the property list');
+    return result;
+}
+const asDict = (value) => typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+const asString = (value) => typeof value === 'string' ? value : undefined;
+const asArray = (value) => Array.isArray(value) ? value : [];
+function settingsOf(dict) {
+    const result = {};
+    for (const [key, value] of Object.entries(dict ?? {})) {
+        if (typeof value === 'string')
+            result[key] = value;
+        else if (Array.isArray(value))
+            result[key] = value.filter((item) => typeof item === 'string');
+    }
+    return result;
+}
+function configurationsOf(objects, listId) {
+    const result = new Map();
+    const list = asDict(objects[listId ?? '']);
+    for (const id of asArray(list?.buildConfigurations)) {
+        const configuration = asDict(objects[asString(id) ?? '']);
+        const name = asString(configuration?.name);
+        if (configuration && name)
+            result.set(name, settingsOf(asDict(configuration.buildSettings)));
+    }
+    return result;
+}
+/** Reads the native targets of a parsed project.pbxproj. */
+export function readTargets(pbxproj) {
+    const objects = asDict(asDict(pbxproj)?.objects);
+    const rootId = asString(asDict(pbxproj)?.rootObject);
+    if (!objects || !rootId)
+        throw new XcodeProjectError('project.pbxproj has no objects.');
+    const project = asDict(objects[rootId]);
+    if (!project)
+        throw new XcodeProjectError('project.pbxproj has no root object.');
+    const projectConfigurations = configurationsOf(objects, asString(project.buildConfigurationList));
+    const targets = [];
+    for (const id of asArray(project.targets)) {
+        const target = asDict(objects[asString(id) ?? '']);
+        if (asString(target?.isa) !== 'PBXNativeTarget' || !target)
+            continue;
+        const configurations = {};
+        for (const [name, settings] of configurationsOf(objects, asString(target.buildConfigurationList))) {
+            configurations[name] = { ...projectConfigurations.get(name), ...settings };
+        }
+        targets.push({
+            name: asString(target.name) ?? asString(target.productName) ?? 'unnamed',
+            productType: asString(target.productType) ?? '',
+            configurations,
+        });
+    }
+    return targets;
+}
+/**
+ * Reads `<path>.xcodeproj/project.pbxproj` when it is a regular file inside `root` (by default
+ * the .xcodeproj folder itself).
+ */
+export async function readXcodeProject(path, root = path) {
+    const file = join(path, 'project.pbxproj');
+    const read = await readProjectFile(file, root);
+    if (!read.found)
+        throw new XcodeProjectError(`${file} ${NOT_READ[read.reason]}`);
+    const text = read.bytes.toString('utf8');
+    return { path, sourceRoot: dirname(resolve(path)), targets: readTargets(parseOpenStep(text)) };
+}
+const APP_PRODUCT_TYPES = new Set([
+    'com.apple.product-type.application',
+    'com.apple.product-type.application.on-demand-install-capable', // App Clip
+]);
+const setting = (settings, key) => {
+    const value = settings[key];
+    return typeof value === 'string' ? value : value?.join(' ');
+};
+/** Whether the target builds with the iOS SDK (SDKROOT iphoneos, or `auto` listing iphoneos). */
+export function buildsForIOS(settings) {
+    const sdk = setting(settings, 'SDKROOT');
+    if (sdk === undefined)
+        return false;
+    if (sdk.startsWith('iphoneos'))
+        return true;
+    if (sdk === 'auto')
+        return /\biphoneos\b/.test(setting(settings, 'SUPPORTED_PLATFORMS') ?? '');
+    return false;
+}
+/** iOS app targets (apps and App Clips): the ones UIKit's launch check applies to. */
+export function iosAppTargets(project) {
+    return project.targets.filter((target) => APP_PRODUCT_TYPES.has(target.productType) &&
+        Object.values(target.configurations).some(buildsForIOS));
+}
+const VARIABLE = /\$\(([A-Za-z0-9_]+)\)|\$\{([A-Za-z0-9_]+)\}/g;
+/**
+ * The Info.plist files a target's configurations name in INFOPLIST_FILE, as absolute paths.
+ * $(SRCROOT), $(PROJECT_DIR), $(TARGET_NAME) and $(PRODUCT_NAME) are expanded; a path that still
+ * contains an unknown variable is returned in `unresolved`.
+ */
+export function infoPlistFiles(project, target) {
+    const files = new Set();
+    const unresolved = new Set();
+    for (const settings of Object.values(target.configurations)) {
+        const raw = setting(settings, 'INFOPLIST_FILE');
+        if (!raw)
+            continue;
+        const known = {
+            SRCROOT: project.sourceRoot,
+            PROJECT_DIR: project.sourceRoot,
+            TARGET_NAME: target.name,
+            PRODUCT_NAME: setting(settings, 'PRODUCT_NAME')?.replace(VARIABLE, target.name) ?? target.name,
+        };
+        let missing = false;
+        const expanded = raw.replace(VARIABLE, (whole, round, curly) => {
+            const value = known[round ?? curly ?? ''];
+            if (value === undefined)
+                missing = true;
+            return value ?? whole;
+        });
+        if (missing)
+            unresolved.add(raw);
+        else
+            files.add(resolve(project.sourceRoot, expanded));
+    }
+    return { files: [...files], unresolved: [...unresolved] };
+}
+/** Whether every configuration of the target has Xcode generate (part of) its Info.plist. */
+export function generatesInfoPlist(target) {
+    const values = Object.values(target.configurations);
+    return (values.length > 0 &&
+        values.every((settings) => setting(settings, 'GENERATE_INFOPLIST_FILE') === 'YES'));
+}
+//# sourceMappingURL=pbxproj.js.map

package/dist/collect/plist-binary.d.ts

@@ -0,0 +1,2 @@
+import { type PlistValue } from './plist-value.js';
+export declare function parseBinaryPlist(bytes: Uint8Array): PlistValue;

package/dist/collect/plist-binary.js

@@ -0,0 +1,123 @@
+// Binary property lists (bplist00), the format found in built apps:
+// https://opensource.apple.com/source/CF/CF-1153.18/CFBinaryPList.c
+import { BINARY_MAGIC, PlistError } from './plist-value.js';
+const APPLE_EPOCH_MS = Date.UTC(2001, 0, 1);
+export function parseBinaryPlist(bytes) {
+    if (bytes.length < BINARY_MAGIC.length + 32)
+        throw new PlistError('Binary plist is too short.');
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const trailer = bytes.length - 32;
+    const offsetSize = view.getUint8(trailer + 6);
+    const refSize = view.getUint8(trailer + 7);
+    const objectCount = Number(view.getBigUint64(trailer + 8));
+    const topObject = Number(view.getBigUint64(trailer + 16));
+    const tableOffset = Number(view.getBigUint64(trailer + 24));
+    if (offsetSize < 1 || offsetSize > 8 || refSize < 1 || refSize > 8) {
+        throw new PlistError('Binary plist trailer is not valid.');
+    }
+    if (tableOffset + objectCount * offsetSize > trailer || topObject >= objectCount) {
+        throw new PlistError('Binary plist offset table is out of range.');
+    }
+    const readUint = (at, size) => {
+        if (at + size > bytes.length)
+            throw new PlistError('Binary plist reads past its end.');
+        let value = 0;
+        for (let index = 0; index < size; index++)
+            value = value * 256 + (bytes[at + index] ?? 0);
+        return value;
+    };
+    const offsetOf = (ref) => readUint(tableOffset + ref * offsetSize, offsetSize);
+    const visiting = new Set();
+    const lengthAt = (at, info) => {
+        if (info !== 0xf)
+            return [info, at + 1];
+        const marker = bytes[at + 1] ?? 0;
+        if (marker >> 4 !== 0x1)
+            throw new PlistError('Binary plist length is not an integer.');
+        const size = 1 << (marker & 0xf);
+        return [readUint(at + 2, size), at + 2 + size];
+    };
+    const read = (ref) => {
+        if (ref >= objectCount)
+            throw new PlistError('Binary plist object reference is out of range.');
+        if (visiting.has(ref))
+            throw new PlistError('Binary plist contains a reference cycle.');
+        visiting.add(ref);
+        try {
+            return readObject(offsetOf(ref));
+        }
+        finally {
+            visiting.delete(ref);
+        }
+    };
+    const readObject = (at) => {
+        const marker = bytes[at];
+        if (marker === undefined)
+            throw new PlistError('Binary plist object is out of range.');
+        const type = marker >> 4;
+        const info = marker & 0xf;
+        switch (type) {
+            case 0x0:
+                if (info === 0x8)
+                    return false;
+                if (info === 0x9)
+                    return true;
+                throw new PlistError(`Unsupported binary plist marker 0x${marker.toString(16)}.`);
+            case 0x1: {
+                const size = 1 << info;
+                if (size === 16)
+                    return view.getBigInt64(at + 9);
+                if (size === 8) {
+                    const big = view.getBigInt64(at + 1);
+                    return Number.isSafeInteger(Number(big)) ? Number(big) : big;
+                }
+                return readUint(at + 1, size);
+            }
+            case 0x2:
+                return info === 2 ? view.getFloat32(at + 1) : view.getFloat64(at + 1);
+            case 0x3:
+                return new Date(APPLE_EPOCH_MS + view.getFloat64(at + 1) * 1000);
+            case 0x4: {
+                const [length, start] = lengthAt(at, info);
+                return Uint8Array.from(bytes.subarray(start, start + length));
+            }
+            case 0x5: {
+                const [length, start] = lengthAt(at, info);
+                return new TextDecoder('latin1').decode(bytes.subarray(start, start + length));
+            }
+            case 0x6: {
+                const [length, start] = lengthAt(at, info);
+                let text = '';
+                for (let index = 0; index < length; index++) {
+                    text += String.fromCharCode(readUint(start + index * 2, 2));
+                }
+                return text;
+            }
+            case 0x8:
+                return readUint(at + 1, info + 1);
+            case 0xa: {
+                const [length, start] = lengthAt(at, info);
+                const items = [];
+                for (let index = 0; index < length; index++) {
+                    items.push(read(readUint(start + index * refSize, refSize)));
+                }
+                return items;
+            }
+            case 0xd: {
+                const [length, start] = lengthAt(at, info);
+                const dict = {};
+                for (let index = 0; index < length; index++) {
+                    const key = read(readUint(start + index * refSize, refSize));
+                    if (typeof key !== 'string')
+                        throw new PlistError('Binary plist dictionary key is not a string.');
+                    dict[key] = read(readUint(start + (length + index) * refSize, refSize));
+                }
+                return dict;
+            }
+            default:
+                throw new PlistError(`Unsupported binary plist marker 0x${marker.toString(16)}.`);
+        }
+    };
+    return read(topObject);
+}
+//# sourceMappingURL=plist-binary.js.map

package/dist/collect/plist-value.d.ts

@@ -0,0 +1,15 @@
+export type PlistValue = string | number | bigint | boolean | Date | Uint8Array | PlistValue[] | PlistDict;
+export interface PlistDict {
+    [key: string]: PlistValue;
+}
+export interface ParsedPlist {
+    value: PlistValue;
+    /** 1-based line of each top-level `<key>` in an XML plist; empty for binary plists. */
+    keyLines: ReadonlyMap<string, number>;
+}
+export declare class PlistError extends Error {
+    name: string;
+}
+/** The first bytes of a binary property list. */
+export declare const BINARY_MAGIC = "bplist00";
+export declare function isDict(value: PlistValue | undefined): value is PlistDict;

package/dist/collect/plist-value.js

@@ -0,0 +1,14 @@
+// The values a property list holds and the error the plist readers throw.
+export class PlistError extends Error {
+    name = 'PlistError';
+}
+/** The first bytes of a binary property list. */
+export const BINARY_MAGIC = 'bplist00';
+export function isDict(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date) &&
+        !(value instanceof Uint8Array));
+}
+//# sourceMappingURL=plist-value.js.map

package/dist/collect/plist-xml.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedPlist } from './plist-value.js';
+export declare function parseXmlPlist(xml: string): ParsedPlist;

package/dist/collect/plist-xml.js

@@ -0,0 +1,195 @@
+// XML property lists, the format Xcode writes into projects. Only what Info.plist files use.
+import { lineIndex } from '../core/lines.js';
+import { PlistError } from './plist-value.js';
+const ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-z]+);/g, (whole, entity) => {
+        if (entity.startsWith('#x'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        if (entity.startsWith('#'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        return ENTITIES[entity] ?? whole;
+    });
+}
+function tokenize(xml) {
+    const tokens = [];
+    const tag = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!DOCTYPE[^>]*>|<!\[CDATA\[([\s\S]*?)\]\]>|<(\/?)([A-Za-z_][\w.-]*)[^>]*?(\/?)>/g;
+    let last = 0;
+    for (let match = tag.exec(xml); match; match = tag.exec(xml)) {
+        if (match.index > last) {
+            tokens.push({
+                kind: 'text',
+                name: '',
+                text: decodeEntities(xml.slice(last, match.index)),
+                offset: last,
+            });
+        }
+        last = tag.lastIndex;
+        if (match[1] !== undefined) {
+            tokens.push({ kind: 'text', name: '', text: match[1], offset: match.index });
+        }
+        else if (match[3]) {
+            const kind = match[2] ? 'close' : match[4] ? 'empty' : 'open';
+            tokens.push({ kind, name: match[3], text: '', offset: match.index });
+        }
+    }
+    if (last < xml.length) {
+        tokens.push({ kind: 'text', name: '', text: decodeEntities(xml.slice(last)), offset: last });
+    }
+    // Text between elements is whitespace except inside <key>, <string> and friends; merging
+    // adjacent text (CDATA next to plain text) keeps one text token per element.
+    const merged = [];
+    for (const token of tokens) {
+        const previous = merged.at(-1);
+        if (token.kind === 'text' && previous?.kind === 'text')
+            previous.text += token.text;
+        else
+            merged.push(token);
+    }
+    return merged;
+}
+class XmlReader {
+    tokens;
+    lineAt;
+    index = 0;
+    keyLines = new Map();
+    constructor(tokens, lineAt) {
+        this.tokens = tokens;
+        this.lineAt = lineAt;
+    }
+    next() {
+        while (this.index < this.tokens.length) {
+            const token = this.tokens[this.index++];
+            if (token && !(token.kind === 'text' && token.text.trim() === ''))
+                return token;
+        }
+        return undefined;
+    }
+    peek() {
+        const saved = this.index;
+        const token = this.next();
+        this.index = saved;
+        return token;
+    }
+    textUntil(name) {
+        let text = '';
+        for (let token = this.tokens[this.index++]; token; token = this.tokens[this.index++]) {
+            if (token.kind === 'text')
+                text += token.text;
+            else if (token.kind === 'close' && token.name === name)
+                return text;
+            else
+                throw new PlistError(`Unexpected <${token.name}> inside <${name}>.`);
+        }
+        throw new PlistError(`<${name}> is not closed.`);
+    }
+    document() {
+        const root = this.next();
+        if (root?.name !== 'plist' || root.kind !== 'open') {
+            throw new PlistError('Not a property list: no <plist> element.');
+        }
+        const value = this.value(true);
+        const end = this.next();
+        if (end?.kind !== 'close' || end.name !== 'plist') {
+            throw new PlistError('Not a property list: expected </plist>.');
+        }
+        return value;
+    }
+    value(topLevel = false) {
+        const token = this.next();
+        if (!token || token.kind === 'text' || token.kind === 'close') {
+            throw new PlistError('Expected a value element.');
+        }
+        if (token.kind === 'empty')
+            return this.emptyValue(token.name);
+        switch (token.name) {
+            case 'dict':
+                return this.dict(topLevel);
+            case 'array':
+                return this.array();
+            case 'string':
+                return this.textUntil('string');
+            case 'integer': {
+                const text = this.textUntil('integer').trim();
+                if (!/^[+-]?\d+$/.test(text))
+                    throw new PlistError(`Not an integer: ${text}`);
+                const big = BigInt(text);
+                return Number.isSafeInteger(Number(big)) ? Number(big) : big;
+            }
+            case 'real': {
+                const number = Number(this.textUntil('real').trim());
+                if (Number.isNaN(number))
+                    throw new PlistError('Not a real number.');
+                return number;
+            }
+            case 'true':
+            case 'false':
+                this.textUntil(token.name);
+                return token.name === 'true';
+            case 'date':
+                return new Date(this.textUntil('date').trim());
+            case 'data':
+                return Uint8Array.from(Buffer.from(this.textUntil('data').replace(/\s+/g, ''), 'base64'));
+            default:
+                throw new PlistError(`Unknown element <${token.name}>.`);
+        }
+    }
+    emptyValue(name) {
+        switch (name) {
+            case 'true':
+                return true;
+            case 'false':
+                return false;
+            case 'dict':
+                return {};
+            case 'array':
+                return [];
+            case 'string':
+                return '';
+            case 'data':
+                return new Uint8Array();
+            default:
+                throw new PlistError(`Unknown element <${name}/>.`);
+        }
+    }
+    dict(topLevel) {
+        const result = {};
+        for (;;) {
+            const token = this.peek();
+            if (!token)
+                throw new PlistError('<dict> is not closed.');
+            if (token.kind === 'close' && token.name === 'dict') {
+                this.next();
+                return result;
+            }
+            const keyToken = this.next();
+            if (keyToken?.name !== 'key')
+                throw new PlistError('Expected <key> in <dict>.');
+            const key = keyToken.kind === 'empty' ? '' : this.textUntil('key');
+            if (topLevel)
+                this.keyLines.set(key, this.lineAt(keyToken.offset));
+            result[key] = this.value();
+        }
+    }
+    array() {
+        const result = [];
+        for (;;) {
+            const token = this.peek();
+            if (!token)
+                throw new PlistError('<array> is not closed.');
+            if (token.kind === 'close' && token.name === 'array') {
+                this.next();
+                return result;
+            }
+            result.push(this.value());
+        }
+    }
+}
+export function parseXmlPlist(xml) {
+    const text = xml.replace(/^/, '');
+    if (!/<plist[\s>]/.test(text))
+        throw new PlistError('Not a property list: no <plist> element.');
+    const reader = new XmlReader(tokenize(text), lineIndex(text));
+    return { value: reader.document(), keyLines: reader.keyLines };
+}
+//# sourceMappingURL=plist-xml.js.map

package/dist/collect/plist.d.ts

@@ -0,0 +1,6 @@
+import { type ParsedPlist } from './plist-value.js';
+export { parseBinaryPlist } from './plist-binary.js';
+export { isDict, type ParsedPlist, type PlistDict, PlistError, type PlistValue, } from './plist-value.js';
+export { parseXmlPlist } from './plist-xml.js';
+/** Parses an XML or binary property list. Throws PlistError for anything else. */
+export declare function parsePlist(data: Uint8Array | string): ParsedPlist;

package/dist/collect/plist.js

@@ -0,0 +1,19 @@
+// Property list reader for Info.plist files: the XML format Xcode writes into projects and the
+// binary format (bplist00) found in built apps. No dependencies; only what Info.plist files use.
+import { parseBinaryPlist } from './plist-binary.js';
+import { BINARY_MAGIC } from './plist-value.js';
+import { parseXmlPlist } from './plist-xml.js';
+export { parseBinaryPlist } from './plist-binary.js';
+export { isDict, PlistError, } from './plist-value.js';
+export { parseXmlPlist } from './plist-xml.js';
+/** Parses an XML or binary property list. Throws PlistError for anything else. */
+export function parsePlist(data) {
+    if (typeof data !== 'string') {
+        const head = new TextDecoder('latin1').decode(data.subarray(0, BINARY_MAGIC.length));
+        if (head === BINARY_MAGIC)
+            return { value: parseBinaryPlist(data), keyLines: new Map() };
+        return parseXmlPlist(new TextDecoder().decode(data));
+    }
+    return parseXmlPlist(data);
+}
+//# sourceMappingURL=plist.js.map

package/dist/collect/regions.d.ts

@@ -0,0 +1,9 @@
+import type { SourceFile, SourceIndex, TypeRegion } from './sources.js';
+export declare function swiftRegions(file: SourceFile): TypeRegion[];
+export declare function objcRegions(file: SourceFile): TypeRegion[];
+/** Classes that derive, directly or through other classes in the app, from one of `bases`. */
+export declare function derivedFrom(regions: TypeRegion[], bases: readonly string[]): Set<string>;
+/** The innermost type region of `file` that contains `offset`. */
+export declare function regionAt(index: SourceIndex, file: SourceFile, offset: number): TypeRegion | undefined;
+/** Whether `offset` in `file` is inside the body of a type in `names` (class or extension). */
+export declare function insideTypeNamed(index: SourceIndex, file: SourceFile, offset: number, names: ReadonlySet<string>): boolean;