@esportsplus/typescript 0.31.0 → 0.32.0

package/build/probe/channels.js

@@ -0,0 +1,16 @@
+import { createAsyncChannel } from './async/channel.js';
+import { createExceptionsChannel } from './exceptions/channel.js';
+import { createResourcesChannel } from './resources/channel.js';
+const FACTORIES = {
+    async: (config) => createAsyncChannel(config),
+    exceptions: () => createExceptionsChannel(),
+    resources: (config) => createResourcesChannel(config),
+};
+function channelFor(name, config) {
+    const factory = FACTORIES[name];
+    return factory ? factory(config) : undefined;
+}
+function implementedChannels() {
+    return Object.keys(FACTORIES);
+}
+export { channelFor, implementedChannels };

package/build/probe/exceptions/channel.d.ts

@@ -0,0 +1,5 @@
+import type { Channel } from '../kernel/types.js';
+import { type ExceptionsValue } from './value.js';
+declare function overlayThrows(entry: unknown): boolean;
+declare function createExceptionsChannel(): Channel<ExceptionsValue>;
+export { createExceptionsChannel, overlayThrows };

package/build/probe/exceptions/channel.js

@@ -0,0 +1,669 @@
+import * as NodeFS from 'node:fs';
+import * as ts from '../adapter.js';
+import { bodyOf, calleeSelectors, paramSymbols } from '../kernel/ast.js';
+import { isFunctionLike, locationOf } from '../kernel/ids.js';
+import { declaredExceptions } from './jsdoc.js';
+import { bottom, constituentsOf, equals, isEmpty, join, originsOf, refOfType, render, single, subtract, top, TOP_KEY, widen, withOrigin, } from './value.js';
+function overlayThrows(entry) {
+    const e = (entry ?? {});
+    return ((Array.isArray(e.exceptions) && e.exceptions.length > 0) ||
+        (Array.isArray(e.exceptionsFromCallbacks) &&
+            e.exceptionsFromCallbacks.length > 0));
+}
+function createExceptionsChannel() {
+    let unhandledCache;
+    const typeCache = new Map();
+    const typeAt = (checker, node) => {
+        if (typeCache.has(node)) {
+            return typeCache.get(node);
+        }
+        const type = checker.getTypeAtLocation(node);
+        typeCache.set(node, type);
+        return type;
+    };
+    const computeUnhandled = (ctx) => {
+        if (unhandledCache)
+            return unhandledCache;
+        const roots = ctx.roots();
+        const origins = new Set();
+        for (const r of roots) {
+            for (const o of originsOf(ctx.summaryOf(r).value))
+                origins.add(`${o.fileName}:${o.pos}`);
+        }
+        unhandledCache = { origins, active: roots.length > 0 };
+        return unhandledCache;
+    };
+    return {
+        name: 'exceptions',
+        bottom,
+        equals,
+        widen,
+        transfer(ctx) {
+            const env = makeEnv(ctx.checker, ctx.dispatch, ctx.sinks, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt);
+            const body = bodyOf(ctx.fn.node);
+            let value = body ? escapeOf(env, body, undefined) : bottom();
+            const decl = declaredExceptions(ctx.fn.node, ctx.checker);
+            if (decl.declared)
+                value = decl.value;
+            return { value, fromCallbacks: env.fromCallbacks };
+        },
+        diagnose(ctx) {
+            const out = [];
+            const base = makeEnv(ctx.checker, ctx.dispatch, ctx.sinks, ctx.fn, ctx.summaryOf, ctx.resolveCall, typeAt);
+            const env = reportMode(ctx) === 'all'
+                ? { ...base, escapeCache: new Map() }
+                : {
+                    ...base,
+                    escapeCache: new Map(),
+                    unhandled: computeUnhandled(ctx),
+                };
+            const body = bodyOf(ctx.fn.node);
+            const decl = declaredExceptions(ctx.fn.node, ctx.checker);
+            if (decl.declared && body) {
+                const inferred = escapeOf(env, body, undefined);
+                const excess = subtract(inferred, new Set(decl.value.types.keys()));
+                if (!isEmpty(excess)) {
+                    const nn = ctx.fn.node.name;
+                    out.push({
+                        channel: 'exceptions',
+                        message: `Throws ${render(excess)} but declares only ${render(decl.value)}`,
+                        location: locationOf(nn ?? ctx.fn.node, ctx.fn.sourceFile),
+                        related: [],
+                    });
+                }
+            }
+            if (errorCauseEnabled(ctx) && body)
+                checkErrorCause(body, out);
+            if (ctx.isBoundary && body)
+                walkDiagnostics(env, ctx, body, undefined, undefined, out);
+            return out;
+        },
+    };
+}
+function makeEnv(checker, dispatch, sinks, fn, summaryOf, resolveCall, typeAt) {
+    const symbols = paramSymbols(checker, fn.node);
+    return {
+        checker,
+        dispatch,
+        sinks,
+        fn,
+        summaryOf,
+        resolveCall,
+        escapeCache: undefined,
+        typeTable: new Map(),
+        typeAt: (node) => typeAt(checker, node),
+        paramSymbols: symbols,
+        fromCallbacks: new Set(),
+    };
+}
+function escapeOf(env, node, binding) {
+    const cached = env.escapeCache?.get(node)?.get(binding);
+    if (cached) {
+        return cached;
+    }
+    let acc = bottom();
+    const visit = (n) => {
+        if (isFunctionLike(n))
+            return;
+        if (ts.isTryStatement(n)) {
+            acc = join(acc, tryEscape(env, n, binding));
+            return;
+        }
+        if (ts.isThrowStatement(n)) {
+            if (n.expression && !isBindingRef(env, n.expression, binding)) {
+                const thrown = valueOfType(env, env.typeAt(n.expression));
+                acc = join(acc, withOrigin(thrown, originOf(n)));
+            }
+            if (n.expression)
+                ts.forEachChild(n.expression, visit);
+            return;
+        }
+        if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
+            acc = join(acc, callEscape(env, n));
+            ts.forEachChild(n, visit);
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+    if (env.escapeCache) {
+        let bindings = env.escapeCache.get(node);
+        if (!bindings) {
+            bindings = new Map();
+            env.escapeCache.set(node, bindings);
+        }
+        bindings.set(binding, acc);
+    }
+    return acc;
+}
+function tryEscape(env, node, binding) {
+    const tryEsc = escapeOf(env, node.tryBlock, binding);
+    let result;
+    if (node.catchClause) {
+        const bindSym = bindingSymOf(env, node.catchClause) ?? binding;
+        const discharge = dischargedKeys(env, node.catchClause, tryEsc, bindSym);
+        const catchEsc = escapeOf(env, node.catchClause.block, bindSym);
+        result = join(subtract(tryEsc, discharge), catchEsc);
+    }
+    else {
+        result = tryEsc;
+    }
+    if (node.finallyBlock)
+        result = join(result, escapeOf(env, node.finallyBlock, binding));
+    return result;
+}
+function dischargedKeys(env, cc, tryEsc, bindSym) {
+    if (tryEsc.top)
+        return new Set();
+    const allKeys = new Set(tryEsc.types.keys());
+    const rethrows = [];
+    const find = (n) => {
+        if (isFunctionLike(n))
+            return;
+        if (ts.isThrowStatement(n) &&
+            n.expression &&
+            isBindingRef(env, n.expression, bindSym)) {
+            rethrows.push(n);
+        }
+        ts.forEachChild(n, find);
+    };
+    ts.forEachChild(cc.block, find);
+    if (rethrows.length === 0)
+        return allKeys;
+    const rethrown = new Set();
+    for (const rt of rethrows) {
+        const g = guardsFor(env, rt, cc.block, bindSym);
+        if (g.unresolved ||
+            (g.positives.length === 0 && g.negatives.length === 0)) {
+            return new Set();
+        }
+        for (const key of allKeys) {
+            const c = env.typeTable.get(key) ?? resolveKeyType(env, key);
+            if (!c) {
+                rethrown.add(key);
+                continue;
+            }
+            const okPos = g.positives.every((p) => isSubclassOf(c, p));
+            const okNeg = g.negatives.every((neg) => !isSubclassOf(c, neg));
+            if (okPos && okNeg)
+                rethrown.add(key);
+        }
+    }
+    const discharge = new Set();
+    for (const key of allKeys)
+        if (!rethrown.has(key))
+            discharge.add(key);
+    return discharge;
+}
+function guardsFor(env, rethrow, catchBlock, bindSym) {
+    const positives = [];
+    const negatives = [];
+    let unresolved = false;
+    let child = rethrow;
+    let parent = rethrow.parent;
+    const stop = catchBlock.parent;
+    while (parent && parent !== stop) {
+        if (ts.isIfStatement(parent) &&
+            (child === parent.thenStatement || child === parent.elseStatement)) {
+            const info = parseInstanceof(env, parent.expression, bindSym);
+            if (!info) {
+                unresolved = true;
+            }
+            else {
+                const condTrue = child === parent.thenStatement;
+                if (condTrue === info.positive)
+                    positives.push(info.type);
+                else
+                    negatives.push(info.type);
+            }
+        }
+        if (ts.isBlock(parent)) {
+            for (const stmt of parent.statements) {
+                if (stmt === child)
+                    break;
+                const g = guardExit(env, stmt, bindSym);
+                if (g)
+                    (g.positive ? positives : negatives).push(g.type);
+            }
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return { positives, negatives, unresolved };
+}
+function parseInstanceof(env, expr, bindSym) {
+    if (ts.isParenthesizedExpression(expr))
+        return parseInstanceof(env, expr.expression, bindSym);
+    if (ts.isPrefixUnaryExpression(expr) &&
+        expr.operator === ts.SyntaxKind.ExclamationToken) {
+        const inner = parseInstanceof(env, expr.operand, bindSym);
+        return inner
+            ? { type: inner.type, positive: !inner.positive }
+            : undefined;
+    }
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+        if (!isBindingRef(env, expr.left, bindSym))
+            return undefined;
+        const rhsType = env.typeAt(expr.right);
+        if (!rhsType)
+            return undefined;
+        const ctorSig = env.checker.getSignaturesOfType(rhsType, ts.SignatureKind.Construct)[0];
+        const type = ctorSig
+            ? (env.checker.getReturnTypeOfSignature(ctorSig) ?? rhsType)
+            : rhsType;
+        return { type, positive: true };
+    }
+    return undefined;
+}
+function guardExit(env, stmt, bindSym) {
+    if (!ts.isIfStatement(stmt) || stmt.elseStatement)
+        return undefined;
+    if (!exits(stmt.thenStatement))
+        return undefined;
+    const info = parseInstanceof(env, stmt.expression, bindSym);
+    if (!info)
+        return undefined;
+    return { type: info.type, positive: !info.positive };
+}
+function exits(stmt) {
+    if (ts.isBlock(stmt)) {
+        const last = stmt.statements[stmt.statements.length - 1];
+        return last ? exits(last) : false;
+    }
+    return (ts.isReturnStatement(stmt) ||
+        ts.isThrowStatement(stmt) ||
+        ts.isBreakStatement(stmt) ||
+        ts.isContinueStatement(stmt));
+}
+function resolveKeyType(env, key) {
+    if (key === TOP_KEY)
+        return undefined;
+    const colon = key.indexOf(':');
+    const qname = colon >= 0 ? key.slice(colon + 1) : key;
+    const dot = qname.lastIndexOf('.');
+    const simple = dot >= 0 ? qname.slice(dot + 1) : qname;
+    if (!/^[A-Za-z_$][\w$]*$/.test(simple))
+        return undefined;
+    const sym = env.checker.resolveName(simple, ts.SymbolFlags.Type | ts.SymbolFlags.Value, env.fn.node, false);
+    if (!sym)
+        return undefined;
+    const t = env.checker.getDeclaredTypeOfSymbol(sym);
+    if (t)
+        env.typeTable.set(key, t);
+    return t;
+}
+function isSubclassOf(c, base, seen = new Set()) {
+    if (c === base)
+        return true;
+    const cs = c.getSymbol();
+    const bs = base.getSymbol();
+    if (cs && bs && cs === bs)
+        return true;
+    if (seen.has(c))
+        return false;
+    seen.add(c);
+    const bases = c.getBaseTypes() ?? [];
+    for (const b of bases)
+        if (isSubclassOf(b, base, seen))
+            return true;
+    return false;
+}
+function callEscape(env, call) {
+    detectParamCall(env, call);
+    const res = env.resolveCall(call);
+    let v = bottom();
+    for (const target of res.targets) {
+        const s = env.summaryOf(target);
+        v = join(v, s.value);
+        for (const i of s.fromCallbacks) {
+            for (const f of res.functionArgs.get(i) ?? [])
+                v = join(v, env.summaryOf(f).value);
+        }
+    }
+    if (res.overlay)
+        v = join(v, overlayValue(env, res, call));
+    if (res.unresolved && !res.overlay && env.dispatch === 'pessimist')
+        v = join(v, top());
+    const sink = matchSink(env, call);
+    if (sink)
+        v = applySink(v, sink);
+    return v;
+}
+function overlayValue(env, res, call) {
+    const entry = (res.overlay?.entry ?? {});
+    let v = bottom();
+    if (Array.isArray(entry.exceptions)) {
+        for (const name of entry.exceptions)
+            if (typeof name === 'string')
+                v = join(v, namedValue(env, name, call));
+    }
+    if (Array.isArray(entry.exceptionsFromCallbacks)) {
+        for (const i of entry.exceptionsFromCallbacks) {
+            if (typeof i !== 'number')
+                continue;
+            for (const f of res.functionArgs.get(i) ?? [])
+                v = join(v, env.summaryOf(f).value);
+        }
+    }
+    return v;
+}
+function namedValue(env, name, location) {
+    const sym = env.checker.resolveName(name, ts.SymbolFlags.Type, location, false);
+    if (sym) {
+        const t = env.checker.getDeclaredTypeOfSymbol(sym);
+        if (t)
+            return valueOfType(env, t);
+    }
+    return single(name, name);
+}
+function detectParamCall(env, call) {
+    if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+        return;
+    const sym = env.checker.getSymbolAtLocation(call.expression);
+    if (!sym)
+        return;
+    const idx = env.paramSymbols.get(sym);
+    if (idx !== undefined)
+        env.fromCallbacks.add(idx);
+}
+function matchSink(env, call) {
+    if (!ts.isCallExpression(call))
+        return undefined;
+    const names = calleeSelectors(call.expression);
+    for (const s of env.sinks)
+        if (names.has(s.callee))
+            return s;
+    return undefined;
+}
+function applySink(v, sink) {
+    if (!sink.absorbs)
+        return bottom();
+    if (v.top)
+        return v;
+    const absorb = new Set(sink.absorbs);
+    const kept = new Map();
+    const keptOrigins = new Map();
+    for (const [k, d] of v.types) {
+        if (absorb.has(d))
+            continue;
+        kept.set(k, d);
+        const o = v.origins.get(k);
+        if (o)
+            keptOrigins.set(k, o);
+    }
+    return { top: false, types: kept, origins: keptOrigins };
+}
+function reportMode(ctx) {
+    const cc = ctx.channelConfig;
+    if (typeof cc === 'object' && cc !== null) {
+        const r = cc['report'];
+        if (typeof r === 'string')
+            return r;
+    }
+    return 'consumers';
+}
+function consumersOnly(ctx) {
+    const mode = reportMode(ctx);
+    return mode === 'consumers' || mode === 'cross-module';
+}
+function errorCauseEnabled(ctx) {
+    const cc = ctx.channelConfig;
+    return (typeof cc === 'object' &&
+        cc !== null &&
+        cc['errorCause'] === true);
+}
+function hasCauseArg(node) {
+    for (const arg of node.arguments ?? []) {
+        if (!ts.isObjectLiteralExpression(arg))
+            continue;
+        for (const p of arg.properties) {
+            const name = p.name;
+            if (name && ts.isIdentifier(name) && name.text === 'cause')
+                return true;
+        }
+    }
+    return false;
+}
+function checkErrorCause(node, out) {
+    const visit = (n) => {
+        if (isFunctionLike(n))
+            return;
+        if (ts.isCatchClause(n) && n.variableDeclaration) {
+            const scan = (m) => {
+                if (isFunctionLike(m) || ts.isCatchClause(m))
+                    return;
+                if (ts.isThrowStatement(m) &&
+                    m.expression &&
+                    ts.isNewExpression(m.expression) &&
+                    !hasCauseArg(m.expression)) {
+                    out.push({
+                        channel: 'exceptions',
+                        message: 'Rethrow drops the caught error — pass `{ cause }` to preserve it',
+                        location: locationOf(m, m.getSourceFile()),
+                        related: [],
+                    });
+                }
+                ts.forEachChild(m, scan);
+            };
+            ts.forEachChild(n.block, scan);
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+}
+const packageRootCache = new Map();
+function packageRootOf(fileName) {
+    let dir = fileName.replace(/\\/g, '/');
+    const slash = dir.lastIndexOf('/');
+    dir = slash >= 0 ? dir.slice(0, slash) : dir;
+    const visited = [];
+    let root;
+    for (let cur = dir;;) {
+        const cached = packageRootCache.get(cur);
+        if (cached !== undefined) {
+            root = cached;
+            break;
+        }
+        visited.push(cur);
+        if (NodeFS.existsSync(`${cur}/package.json`)) {
+            root = cur;
+            break;
+        }
+        const up = cur.lastIndexOf('/');
+        if (up <= 0) {
+            root = cur;
+            break;
+        }
+        cur = cur.slice(0, up);
+    }
+    for (const visitedDir of visited) {
+        packageRootCache.set(visitedDir, root);
+    }
+    return root;
+}
+function crossesPackageBoundary(env, ctx, call) {
+    const res = env.resolveCall(call);
+    if (res.targets.length === 0)
+        return true;
+    const home = packageRootOf(ctx.fn.fileName);
+    return res.targets.some((t) => packageRootOf(t.fileName) !== home);
+}
+function crossesFileBoundary(env, ctx, call) {
+    const res = env.resolveCall(call);
+    if (res.targets.length === 0)
+        return true;
+    const home = ctx.fn.fileName.replace(/\\/g, '/');
+    return res.targets.some((t) => t.fileName.replace(/\\/g, '/') !== home);
+}
+function reachesTop(env, rem) {
+    const u = env.unhandled;
+    if (!u || !u.active)
+        return true;
+    for (const o of originsOf(rem))
+        if (u.origins.has(`${o.fileName}:${o.pos}`))
+            return true;
+    return false;
+}
+function walkDiagnostics(env, ctx, node, binding, remainder, out) {
+    const visit = (n) => {
+        if (isFunctionLike(n))
+            return;
+        if (ts.isTryStatement(n)) {
+            handleTry(env, ctx, n, binding, remainder, out);
+            return;
+        }
+        if (ts.isThrowStatement(n)) {
+            if (n.expression) {
+                if (!consumersOnly(ctx)) {
+                    if (isBindingRef(env, n.expression, binding)) {
+                        if (remainder && !isEmpty(remainder))
+                            out.push(throwDiagnostic(ctx, n, remainder));
+                    }
+                    else {
+                        const rem = valueOfType(env, env.typeAt(n.expression));
+                        if (!isEmpty(rem))
+                            out.push(throwDiagnostic(ctx, n, rem));
+                    }
+                }
+                ts.forEachChild(n.expression, visit);
+            }
+            return;
+        }
+        if (ts.isCallExpression(n) || ts.isNewExpression(n)) {
+            const rem = callEscape(env, n);
+            const mode = reportMode(ctx);
+            const report = mode === 'all'
+                ? true
+                : mode === 'cross-module'
+                    ? crossesFileBoundary(env, ctx, n) && reachesTop(env, rem)
+                    : crossesPackageBoundary(env, ctx, n) &&
+                        reachesTop(env, rem);
+            if (!isEmpty(rem) && report)
+                out.push(callDiagnostic(env, ctx, n, rem));
+            ts.forEachChild(n, visit);
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+}
+function handleTry(env, ctx, n, binding, remainder, out) {
+    if (n.catchClause) {
+        const tryEsc = escapeOf(env, n.tryBlock, binding);
+        const bindSym = bindingSymOf(env, n.catchClause) ?? binding;
+        const discharge = dischargedKeys(env, n.catchClause, tryEsc, bindSym);
+        const rem = subtract(tryEsc, discharge);
+        walkDiagnostics(env, ctx, n.catchClause.block, bindSym, rem, out);
+    }
+    else {
+        walkDiagnostics(env, ctx, n.tryBlock, binding, remainder, out);
+    }
+    if (n.finallyBlock)
+        walkDiagnostics(env, ctx, n.finallyBlock, binding, remainder, out);
+}
+function originOf(node) {
+    const sf = node.getSourceFile();
+    const start = node.getStart(sf);
+    const { line, character } = sf.getLineAndCharacterOfPosition(start);
+    const raw = node.getText(sf).replace(/\s+/g, ' ').trim();
+    return {
+        fileName: sf.fileName,
+        pos: start,
+        end: node.getEnd(),
+        line: line + 1,
+        column: character + 1,
+        text: raw.length > 120 ? `${raw.slice(0, 117)}…` : raw,
+    };
+}
+function relatedFromOrigins(origins) {
+    return origins.slice(0, 8).map((o) => ({
+        message: o.text,
+        location: {
+            fileName: o.fileName,
+            line: o.line,
+            column: o.column,
+            pos: o.pos,
+            end: o.end,
+        },
+    }));
+}
+function callDiagnostic(env, ctx, call, rem) {
+    const res = env.resolveCall(call);
+    const from = calleeDisplay(res, call);
+    const suffix = from ? ` (from ${from})` : '';
+    const origins = originsOf(rem);
+    return {
+        channel: 'exceptions',
+        message: `Call may throw ${render(rem)}${suffix} with no catch on the path to \`${ctx.fn.name}\``,
+        location: locationOf(call, call.getSourceFile()),
+        related: origins.length > 0
+            ? relatedFromOrigins(origins)
+            : buildRelated(ctx, res.targets),
+    };
+}
+function throwDiagnostic(ctx, node, rem) {
+    return {
+        channel: 'exceptions',
+        message: `Throw may throw ${render(rem)} with no catch on the path to \`${ctx.fn.name}\``,
+        location: locationOf(node, node.getSourceFile()),
+        related: buildRelated(ctx, []),
+    };
+}
+function calleeDisplay(res, call) {
+    if (res.overlay)
+        return res.overlay.symbol;
+    if (res.targets[0])
+        return res.targets[0].name;
+    const callee = ts.isCallExpression(call) || ts.isNewExpression(call)
+        ? call.expression
+        : undefined;
+    if (callee && ts.isPropertyAccessExpression(callee))
+        return callee.getText();
+    if (callee && ts.isIdentifier(callee))
+        return callee.text;
+    return undefined;
+}
+function buildRelated(ctx, targets) {
+    const related = [];
+    for (const t of targets) {
+        related.push({
+            message: `may throw here in ${t.name}`,
+            location: locationOf(t.node, t.sourceFile),
+        });
+    }
+    for (const f of ctx.pathToBoundary(ctx.fn)) {
+        related.push({
+            message: `on the path to boundary via ${f.name}`,
+            location: locationOf(f.node, f.sourceFile),
+        });
+    }
+    return related;
+}
+function valueOfType(env, type) {
+    let v = bottom();
+    if (!type)
+        return v;
+    for (const t of constituentsOf(type)) {
+        const r = refOfType(env.checker, t);
+        if (r.top) {
+            v = join(v, top());
+            continue;
+        }
+        env.typeTable.set(r.key, t);
+        v = join(v, single(r.key, r.display));
+    }
+    return v;
+}
+function bindingSymOf(env, cc) {
+    const vd = cc.variableDeclaration;
+    if (vd && ts.isIdentifier(vd.name))
+        return env.checker.getSymbolAtLocation(vd.name);
+    return undefined;
+}
+function isBindingRef(env, expr, bindSym) {
+    if (!bindSym || !ts.isIdentifier(expr))
+        return false;
+    return env.checker.getSymbolAtLocation(expr) === bindSym;
+}
+export { createExceptionsChannel, overlayThrows };

package/build/probe/exceptions/jsdoc.d.ts

@@ -0,0 +1,8 @@
+import * as ts from '../adapter.js';
+import type { FunctionLike } from '../kernel/types.js';
+import { type ExceptionsValue } from './value.js';
+declare function declaredExceptions(node: FunctionLike, checker: ts.TypeChecker): {
+    value: ExceptionsValue;
+    declared: boolean;
+};
+export { declaredExceptions };