codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/ast/MemberExtractor.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+class MemberExtractor {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    extractMembers(sourceFile, filePath, serviceName) {
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => (0, node_helpers_1.lineTextAt)(sourceLines, sourceFile, node);
+        const push = (declNode, posNode, name, kind, container, isStatic, hasBody) => {
+            const { line, col } = (0, node_helpers_1.getPos)(sourceFile, posNode);
+            candidates.push({
+                declNode,
+                entry: {
+                    project: serviceName, filePath, name, kind,
+                    signature: lineAt(posNode),
+                    line, endLine: declNode.getEndLineNumber(), col,
+                    container: container.length ? container.join('.') : null,
+                    isStatic, hasBody,
+                },
+            });
+        };
+        for (const cls of [
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration),
+            ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassExpression),
+        ]) {
+            if (ts_morph_1.Node.isClassDeclaration(cls) && cls.getName() && ts_morph_1.Node.isSourceFile(cls.getParent()))
+                continue;
+            const described = this.resolver.describeIndexedNode(cls);
+            if (!described)
+                continue;
+            const posNode = (ts_morph_1.Node.isClassDeclaration(cls) ? cls.getNameNode() : undefined) ?? cls;
+            push(cls, posNode, described.name, 'class', described.container, false, true);
+        }
+        for (const m of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            const described = this.resolver.describeIndexedNode(m);
+            if (!described)
+                continue;
+            push(m, m.getNameNode(), described.name, 'method', described.container, m.isStatic(), m.getBody() !== undefined);
+        }
+        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.GetAccessor)) {
+            const described = this.resolver.describeIndexedNode(a);
+            if (!described)
+                continue;
+            push(a, a.getNameNode(), described.name, 'get_accessor', described.container, a.isStatic(), true);
+        }
+        for (const a of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SetAccessor)) {
+            const described = this.resolver.describeIndexedNode(a);
+            if (!described)
+                continue;
+            push(a, a.getNameNode(), described.name, 'set_accessor', described.container, a.isStatic(), true);
+        }
+        for (const c of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.Constructor)) {
+            const described = this.resolver.describeIndexedNode(c);
+            if (!described)
+                continue;
+            const kw = c.getFirstChildByKind(ts_morph_1.SyntaxKind.ConstructorKeyword) ?? c;
+            push(c, kw, described.name, 'constructor', described.container, false, c.getBody() !== undefined);
+        }
+        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyDeclaration)) {
+            const described = this.resolver.describeIndexedNode(p);
+            if (!described)
+                continue;
+            push(p, p.getNameNode(), described.name, 'function_property', described.container, p.isStatic(), true);
+        }
+        for (const p of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+            const described = this.resolver.describeIndexedNode(p);
+            if (!described)
+                continue;
+            push(p, p.getNameNode(), described.name, 'function_property', described.container, false, true);
+        }
+        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodSignature)) {
+            const described = this.resolver.describeIndexedNode(s);
+            if (!described)
+                continue;
+            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
+        }
+        for (const s of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertySignature)) {
+            const described = this.resolver.describeIndexedNode(s);
+            if (!described)
+                continue;
+            push(s, s.getNameNode(), described.name, 'method_signature', described.container, false, false);
+        }
+        for (const fn of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(fn.getParent()))
+                continue;
+            const described = this.resolver.describeIndexedNode(fn);
+            if (!described)
+                continue;
+            const nameNode = fn.getNameNode();
+            if (!nameNode)
+                continue;
+            push(fn, nameNode, described.name, 'function', described.container, false, fn.getBody() !== undefined);
+        }
+        for (const iface of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.InterfaceDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(iface.getParent()))
+                continue;
+            const described = this.resolver.describeIndexedNode(iface);
+            if (!described)
+                continue;
+            push(iface, iface.getNameNode(), described.name, 'interface', described.container, false, true);
+        }
+        for (const ta of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.TypeAliasDeclaration)) {
+            if (!ts_morph_1.Node.isModuleBlock(ta.getParent()))
+                continue;
+            const described = this.resolver.describeIndexedNode(ta);
+            if (!described)
+                continue;
+            push(ta, ta.getNameNode(), described.name, 'type', described.container, false, true);
+        }
+        for (const stmt of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableStatement)) {
+            if (!ts_morph_1.Node.isModuleBlock(stmt.getParent()))
+                continue;
+            for (const decl of stmt.getDeclarations()) {
+                const described = this.resolver.describeIndexedNode(decl);
+                if (!described)
+                    continue;
+                push(decl, decl.getNameNode(), described.name, 'variable', described.container, false, true);
+            }
+        }
+        return candidates;
+    }
+}
+exports.MemberExtractor = MemberExtractor;

package/dist/src/ast/TopLevelSymbolExtractor.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from 'ts-morph';
+import type { DeclarationCandidate } from '../declarations/DeclarationTreeBuilder';
+export declare class TopLevelSymbolExtractor {
+    extractSymbols(sourceFile: SourceFile, filePath: string, serviceName: string): DeclarationCandidate[];
+}

package/dist/src/ast/TopLevelSymbolExtractor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopLevelSymbolExtractor = void 0;
+const node_helpers_1 = require("./node-helpers");
+class TopLevelSymbolExtractor {
+    extractSymbols(sourceFile, filePath, serviceName) {
+        const candidates = [];
+        const sourceLines = sourceFile.getFullText().split('\n');
+        const lineAt = (node) => (0, node_helpers_1.lineTextAt)(sourceLines, sourceFile, node);
+        for (const cls of sourceFile.getClasses()) {
+            const name = cls.getName();
+            if (!name)
+                continue;
+            const nameNode = cls.getNameNode() ?? cls;
+            const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+            candidates.push({
+                declNode: cls,
+                entry: {
+                    project: serviceName, filePath, name, kind: 'class',
+                    signature: lineAt(nameNode),
+                    line, endLine: cls.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
+            });
+        }
+        for (const fn of sourceFile.getFunctions()) {
+            const name = fn.getName();
+            if (!name)
+                continue;
+            const nameNode = fn.getNameNode() ?? fn;
+            const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+            candidates.push({
+                declNode: fn,
+                entry: {
+                    project: serviceName, filePath, name, kind: 'function',
+                    signature: lineAt(nameNode),
+                    line, endLine: fn.getEndLineNumber(), col,
+                    container: null, isStatic: false, hasBody: fn.getBody() !== undefined,
+                },
+            });
+        }
+        for (const iface of sourceFile.getInterfaces()) {
+            const nameNode = iface.getNameNode();
+            const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+            candidates.push({
+                declNode: iface,
+                entry: {
+                    project: serviceName, filePath, name: iface.getName(), kind: 'interface',
+                    signature: lineAt(nameNode),
+                    line, endLine: iface.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
+            });
+        }
+        for (const ta of sourceFile.getTypeAliases()) {
+            const nameNode = ta.getNameNode();
+            const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+            candidates.push({
+                declNode: ta,
+                entry: {
+                    project: serviceName, filePath, name: ta.getName(), kind: 'type',
+                    signature: lineAt(nameNode),
+                    line, endLine: ta.getEndLineNumber(), col,
+                    container: null, isStatic: false,
+                },
+            });
+        }
+        for (const stmt of sourceFile.getVariableStatements()) {
+            for (const decl of stmt.getDeclarations()) {
+                const nameNode = decl.getNameNode();
+                const { line, col } = (0, node_helpers_1.getPos)(sourceFile, nameNode);
+                candidates.push({
+                    declNode: decl,
+                    entry: {
+                        project: serviceName, filePath, name: decl.getName(), kind: 'variable',
+                        signature: lineAt(nameNode),
+                        line, endLine: stmt.getEndLineNumber(), col,
+                        container: null, isStatic: false,
+                    },
+                });
+            }
+        }
+        return candidates;
+    }
+}
+exports.TopLevelSymbolExtractor = TopLevelSymbolExtractor;

package/dist/src/ast/graphql-grammar.d.ts

@@ -0,0 +1,24 @@
+import { Node, type Decorator, type ObjectLiteralExpression, type PropertyAssignment, type ShorthandPropertyAssignment } from 'ts-morph';
+import type { SymbolKind } from '../interfaces/IAstParser';
+export declare const GRAPHQL_MODULE = "@nestjs/graphql";
+export declare const GRAPHQL_TYPE_DECORATORS: Set<string>;
+export declare const GRAPHQL_OPERATION_KIND: Record<string, SymbolKind>;
+export declare const GRAPHQL_NAME_RE: RegExp;
+export type GraphqlNameResult = {
+    ok: true;
+    name: string;
+} | {
+    ok: false;
+    reason: 'non-literal-name' | 'invalid-name';
+    value?: string;
+};
+export declare function decoratorIdentifier(dec: Decorator): Node | undefined;
+export declare function literalStringValue(node: Node): string | null;
+export declare function checkGraphqlGrammar(name: string): GraphqlNameResult;
+export declare function isAbstractGraphqlType(args: Node[]): boolean;
+export declare function findNameProperty(obj: ObjectLiteralExpression): PropertyAssignment | ShorthandPropertyAssignment | undefined;
+export declare function peekThroughWrapper(node: Node): {
+    inner: Node;
+    wrapped: boolean;
+};
+export declare function extractResolverIdentifier(argNode: Node): Node | null;

package/dist/src/ast/graphql-grammar.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPHQL_NAME_RE = exports.GRAPHQL_OPERATION_KIND = exports.GRAPHQL_TYPE_DECORATORS = exports.GRAPHQL_MODULE = void 0;
+exports.decoratorIdentifier = decoratorIdentifier;
+exports.literalStringValue = literalStringValue;
+exports.checkGraphqlGrammar = checkGraphqlGrammar;
+exports.isAbstractGraphqlType = isAbstractGraphqlType;
+exports.findNameProperty = findNameProperty;
+exports.peekThroughWrapper = peekThroughWrapper;
+exports.extractResolverIdentifier = extractResolverIdentifier;
+const ts_morph_1 = require("ts-morph");
+exports.GRAPHQL_MODULE = '@nestjs/graphql';
+exports.GRAPHQL_TYPE_DECORATORS = new Set(['ObjectType', 'InputType', 'InterfaceType']);
+exports.GRAPHQL_OPERATION_KIND = {
+    Query: 'graphql_query', Mutation: 'graphql_mutation', Subscription: 'graphql_subscription',
+};
+exports.GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
+function decoratorIdentifier(dec) {
+    const expr = dec.getExpression();
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        const callee = expr.getExpression();
+        return ts_morph_1.Node.isIdentifier(callee) ? callee : undefined;
+    }
+    return ts_morph_1.Node.isIdentifier(expr) ? expr : undefined;
+}
+function literalStringValue(node) {
+    if (ts_morph_1.Node.isStringLiteral(node) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node))
+        return node.getLiteralValue();
+    return null;
+}
+function checkGraphqlGrammar(name) {
+    return exports.GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, reason: 'invalid-name', value: name };
+}
+function isAbstractGraphqlType(args) {
+    return args.some((arg) => {
+        if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
+            return false;
+        const prop = arg.getProperties().find((p) => {
+            if (!ts_morph_1.Node.isPropertyAssignment(p))
+                return false;
+            const nameNode = p.getNameNode();
+            if (ts_morph_1.Node.isIdentifier(nameNode))
+                return nameNode.getText() === 'isAbstract';
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return nameNode.getLiteralValue() === 'isAbstract';
+            return false;
+        });
+        const init = prop?.getInitializer();
+        return init !== undefined && ts_morph_1.Node.isTrueLiteral(init);
+    });
+}
+function findNameProperty(obj) {
+    return obj.getProperties().find((p) => {
+        if (!ts_morph_1.Node.isPropertyAssignment(p) && !ts_morph_1.Node.isShorthandPropertyAssignment(p))
+            return false;
+        const nameNode = p.getNameNode();
+        if (ts_morph_1.Node.isIdentifier(nameNode))
+            return nameNode.getText() === 'name';
+        if (ts_morph_1.Node.isStringLiteral(nameNode))
+            return nameNode.getLiteralValue() === 'name';
+        return false;
+    });
+}
+function peekThroughWrapper(node) {
+    let current = node;
+    let wrapped = false;
+    while (true) {
+        if (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current) || ts_morph_1.Node.isNonNullExpression(current)) {
+            current = current.getExpression();
+            wrapped = true;
+            continue;
+        }
+        break;
+    }
+    return { inner: current, wrapped };
+}
+function extractResolverIdentifier(argNode) {
+    let target = argNode;
+    if (ts_morph_1.Node.isArrowFunction(target)) {
+        const body = target.getBody();
+        if (ts_morph_1.Node.isBlock(body))
+            return null;
+        target = body;
+    }
+    if (ts_morph_1.Node.isIdentifier(target))
+        return target;
+    if (ts_morph_1.Node.isArrayLiteralExpression(target)) {
+        const elements = target.getElements();
+        if (elements.length === 1 && ts_morph_1.Node.isIdentifier(elements[0]))
+            return elements[0];
+    }
+    return null;
+}

package/dist/src/ast/node-helpers.d.ts

@@ -0,0 +1,11 @@
+import { Node, type SourceFile } from 'ts-morph';
+export type ResolveDeclaration = (identifier: Node) => Node | undefined;
+export declare function getPos(sourceFile: SourceFile, node: Node): {
+    line: number;
+    col: number;
+};
+export declare function lineTextAt(sourceLines: string[], sourceFile: SourceFile, node: Node): string;
+export declare function memberName(nameNode: Node | undefined): string | null;
+export declare function unwrapExpr(node: Node): Node;
+export declare function unwrapParent(node: Node): Node | undefined;
+export declare function defaultResolveDeclaration(identifier: Node): Node | undefined;

package/dist/src/ast/node-helpers.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPos = getPos;
+exports.lineTextAt = lineTextAt;
+exports.memberName = memberName;
+exports.unwrapExpr = unwrapExpr;
+exports.unwrapParent = unwrapParent;
+exports.defaultResolveDeclaration = defaultResolveDeclaration;
+const ts_morph_1 = require("ts-morph");
+function getPos(sourceFile, node) {
+    const { line, character } = sourceFile.compilerNode
+        .getLineAndCharacterOfPosition(node.getStart());
+    return { line: line + 1, col: character + 1 };
+}
+function lineTextAt(sourceLines, sourceFile, node) {
+    const { line } = getPos(sourceFile, node);
+    return (sourceLines[line - 1] ?? node.getText().split('\n')[0]).trim();
+}
+function memberName(nameNode) {
+    if (!nameNode)
+        return null;
+    if (ts_morph_1.Node.isPrivateIdentifier(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isIdentifier(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isStringLiteral(nameNode))
+        return nameNode.getLiteralValue();
+    if (ts_morph_1.Node.isNumericLiteral(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isComputedPropertyName(nameNode))
+        return nameNode.getText().replace(/\s+/g, '');
+    return null;
+}
+function unwrapExpr(node) {
+    let current = node;
+    while (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current)) {
+        current = current.getExpression();
+    }
+    return current;
+}
+function unwrapParent(node) {
+    let current = node.getParent();
+    while (current && (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current))) {
+        current = current.getParent();
+    }
+    return current;
+}
+function defaultResolveDeclaration(identifier) {
+    const sym = identifier.getSymbol();
+    if (!sym)
+        return undefined;
+    const firstDecl = sym.getDeclarations()?.[0];
+    const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl) ? (sym.getAliasedSymbol() ?? sym) : sym;
+    return resolved.getDeclarations()?.[0];
+}

package/dist/src/chunking/AstChunker.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from '../config';
+import type { IChunker, ChunkPiece, ChunkOpts } from '../interfaces/IChunker';
+import type { IChunkPostProcessor, IChunkStrategy } from './interfaces';
+export declare class AstChunker implements IChunker {
+    private readonly declarationStrategy;
+    private readonly characterStrategy;
+    private readonly postProcessors;
+    private readonly declarationPostProcessors;
+    private readonly chunkSize;
+    constructor(declarationStrategy: IChunkStrategy, characterStrategy: IChunkStrategy, postProcessors: IChunkPostProcessor[], declarationPostProcessors: IChunkPostProcessor[], config: Config);
+    chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
+}

package/dist/src/chunking/AstChunker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstChunker = void 0;
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
+const SourceLines_1 = require("../declarations/SourceLines");
+class AstChunker {
+    declarationStrategy;
+    characterStrategy;
+    postProcessors;
+    declarationPostProcessors;
+    chunkSize;
+    constructor(declarationStrategy, characterStrategy, postProcessors, declarationPostProcessors, config) {
+        this.declarationStrategy = declarationStrategy;
+        this.characterStrategy = characterStrategy;
+        this.postProcessors = postProcessors;
+        this.declarationPostProcessors = declarationPostProcessors;
+        this.chunkSize = config.indexer.chunkSize;
+    }
+    async chunk(code, opts) {
+        const declarations = opts.declarations ?? DeclarationTree_1.DeclarationTree.EMPTY;
+        const ctx = { lines: new SourceLines_1.SourceLines(code, { jsx: opts.jsx }), declarations, chunkSize: this.chunkSize, removed: [], splitPoints: [], characterSplit: [] };
+        const byDeclarations = !opts.isSchemaFile && opts.strategy !== 'character' && declarations.roots.length > 0;
+        let pieces = await (byDeclarations ? this.declarationStrategy : this.characterStrategy).chunk(ctx, opts);
+        const processors = byDeclarations ? [...this.postProcessors, ...this.declarationPostProcessors] : this.postProcessors;
+        for (const processor of processors)
+            pieces = processor.process(pieces, ctx);
+        return pieces;
+    }
+}
+exports.AstChunker = AstChunker;

package/dist/src/chunking/CharacterChunkStrategy.d.ts

@@ -0,0 +1,8 @@
+import type { ChunkOpts, ChunkPiece } from '../interfaces/IChunker';
+import type { ChunkContext, IChunkStrategy, ITextSplitter } from './interfaces';
+export declare class CharacterChunkStrategy implements IChunkStrategy {
+    private readonly jsSplitter;
+    private readonly schemaSplitter;
+    constructor(jsSplitter: ITextSplitter, schemaSplitter: ITextSplitter);
+    chunk(ctx: ChunkContext, opts: ChunkOpts): Promise<ChunkPiece[]>;
+}

package/dist/src/chunking/CharacterChunkStrategy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CharacterChunkStrategy = void 0;
+class CharacterChunkStrategy {
+    jsSplitter;
+    schemaSplitter;
+    constructor(jsSplitter, schemaSplitter) {
+        this.jsSplitter = jsSplitter;
+        this.schemaSplitter = schemaSplitter;
+    }
+    chunk(ctx, opts) {
+        return (opts.isSchemaFile ? this.schemaSplitter : this.jsSplitter).split(ctx.lines.text, 1);
+    }
+}
+exports.CharacterChunkStrategy = CharacterChunkStrategy;

package/dist/src/chunking/DeclarationChunkStrategy.d.ts

@@ -0,0 +1,15 @@
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { ChunkContext, IChunkStrategy, ISplitPolicy } from './interfaces';
+import { RunPacker } from './RunPacker';
+export declare class DeclarationChunkStrategy implements IChunkStrategy {
+    private readonly policy;
+    private readonly packer;
+    constructor(policy: ISplitPolicy, packer: RunPacker);
+    chunk(ctx: ChunkContext): Promise<ChunkPiece[]>;
+    private splitNode;
+    private coversParent;
+    private splitLevel;
+    private packRuns;
+    private static isShortPrologue;
+    private static gaps;
+}

package/dist/src/chunking/DeclarationChunkStrategy.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationChunkStrategy = void 0;
+const FragmentMerger_1 = require("./FragmentMerger");
+const RunPacker_1 = require("./RunPacker");
+class DeclarationChunkStrategy {
+    policy;
+    packer;
+    constructor(policy, packer) {
+        this.policy = policy;
+        this.packer = packer;
+    }
+    async chunk(ctx) {
+        const roots = ctx.declarations.roots;
+        const removed = DeclarationChunkStrategy.gaps({ start: 1, end: ctx.lines.count }, roots)
+            .flatMap(gap => ctx.lines.importRegions(gap.start, gap.end));
+        if (removed.length > 0 && DeclarationChunkStrategy.isShortPrologue(removed[0].start - 1, ctx.lines)) {
+            removed[0] = { start: 1, end: removed[0].end };
+        }
+        ctx.removed.push(...removed);
+        return this.splitLevel({ start: 1, end: ctx.lines.count }, roots, null, removed, ctx);
+    }
+    async splitNode(node, ctx) {
+        if (ctx.lines.length(node.start, node.end) <= ctx.chunkSize)
+            return RunPacker_1.RunPacker.piece(node, ctx.lines);
+        let children = node.children;
+        while (children.length === 1 && this.coversParent(children[0], node, ctx))
+            children = children[0].children;
+        return this.splitLevel(node, children, node, [], ctx);
+    }
+    coversParent(child, parent, ctx) {
+        if (child.end !== parent.end || child.start < parent.start)
+            return false;
+        for (let n = parent.start; n < child.start; n++) {
+            if (!ctx.lines.isBlank(n) && !ctx.lines.isCommentOnly(n))
+                return false;
+        }
+        return true;
+    }
+    async splitLevel(range, children, boundary, removed, ctx) {
+        const splitPoints = children.filter(c => this.policy.isSplitPoint(c, children, boundary, ctx.lines));
+        const packed = children.filter(c => !splitPoints.includes(c));
+        ctx.splitPoints.push(...splitPoints);
+        const pieces = [];
+        let cursor = range.start;
+        for (const sp of splitPoints) {
+            if (cursor < sp.start)
+                pieces.push(...await this.packRuns({ start: cursor, end: sp.start - 1 }, packed, boundary, removed, ctx));
+            pieces.push(...await this.splitNode(sp, ctx));
+            cursor = sp.end + 1;
+        }
+        if (cursor <= range.end)
+            pieces.push(...await this.packRuns({ start: cursor, end: range.end }, packed, boundary, removed, ctx));
+        return pieces;
+    }
+    async packRuns(span, children, owner, removed, ctx) {
+        const pieces = [];
+        for (const run of DeclarationChunkStrategy.gaps(span, removed)) {
+            pieces.push(...await this.packer.pack(run, children, ctx.lines, ctx.chunkSize, ctx.characterSplit, owner));
+        }
+        return pieces;
+    }
+    static isShortPrologue(end, lines) {
+        if (end < 1)
+            return false;
+        for (let n = lines.line(1).startsWith('#!') ? 2 : 1; n <= end; n++) {
+            if (!lines.isBlank(n) && !lines.isCommentOnly(n) && !lines.isDirective(n))
+                return false;
+        }
+        return lines.slice(1, end).replace(/\s+/g, '').length < FragmentMerger_1.MIN_FRAGMENT_CHARS;
+    }
+    static gaps(span, taken) {
+        const out = [];
+        let cursor = span.start;
+        for (const t of [...taken].sort((a, b) => a.start - b.start)) {
+            if (t.end < cursor || t.start > span.end)
+                continue;
+            if (cursor < t.start)
+                out.push({ start: cursor, end: t.start - 1 });
+            cursor = Math.max(cursor, t.end + 1);
+        }
+        if (cursor <= span.end)
+            out.push({ start: cursor, end: span.end });
+        return out;
+    }
+}
+exports.DeclarationChunkStrategy = DeclarationChunkStrategy;

package/dist/src/chunking/FragmentMerger.d.ts

@@ -0,0 +1,11 @@
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { ChunkContext, IChunkPostProcessor } from './interfaces';
+export declare const MIN_FRAGMENT_CHARS = 60;
+export declare class FragmentMerger implements IChunkPostProcessor {
+    process(pieces: ChunkPiece[], ctx: ChunkContext): ChunkPiece[];
+    private isFragment;
+    private canMerge;
+    private static scope;
+    private static within;
+    private static merge;
+}

package/dist/src/chunking/FragmentMerger.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FragmentMerger = exports.MIN_FRAGMENT_CHARS = void 0;
+const owner_path_1 = require("../owner-path");
+exports.MIN_FRAGMENT_CHARS = 60;
+class FragmentMerger {
+    process(pieces, ctx) {
+        const queue = [...pieces].sort((a, b) => a.startLine - b.startLine);
+        const out = [];
+        for (let i = 0; i < queue.length; i++) {
+            const piece = queue[i];
+            if (!this.isFragment(piece, ctx)) {
+                out.push(piece);
+                continue;
+            }
+            const scope = FragmentMerger.scope(piece, ctx);
+            const prev = out[out.length - 1];
+            if (prev && FragmentMerger.within(prev, scope) && this.canMerge(prev, piece, ctx)) {
+                out[out.length - 1] = FragmentMerger.merge(prev, piece, ctx);
+                continue;
+            }
+            const next = queue[i + 1];
+            if (next && FragmentMerger.within(next, scope) && this.canMerge(piece, next, ctx)) {
+                queue[i + 1] = FragmentMerger.merge(piece, next, ctx);
+                continue;
+            }
+            out.push(piece);
+        }
+        return out;
+    }
+    isFragment(piece, ctx) {
+        return ctx.lines.significantLength(piece.startLine, piece.endLine) < exports.MIN_FRAGMENT_CHARS
+            && (0, owner_path_1.ownedLines)(piece, ctx.declarations, ctx.lines).length === 0;
+    }
+    canMerge(first, second, ctx) {
+        const start = Math.min(first.startLine, second.startLine);
+        const end = Math.max(first.endLine, second.endLine);
+        if (ctx.removed.some(r => r.start > first.endLine && r.end < second.startLine))
+            return false;
+        return ctx.lines.length(start, end) <= ctx.chunkSize;
+    }
+    static scope(piece, ctx) {
+        let best = null;
+        for (const sp of [...ctx.splitPoints, ...ctx.characterSplit]) {
+            if (sp.start > piece.startLine || sp.end < piece.endLine)
+                continue;
+            if (!best || sp.end - sp.start < best.end - best.start)
+                best = sp;
+        }
+        return best;
+    }
+    static within(piece, scope) {
+        return !scope || (scope.start <= piece.startLine && piece.endLine <= scope.end);
+    }
+    static merge(first, second, ctx) {
+        const startLine = Math.min(first.startLine, second.startLine);
+        const endLine = Math.max(first.endLine, second.endLine);
+        return { content: ctx.lines.slice(startLine, endLine), startLine, endLine };
+    }
+}
+exports.FragmentMerger = FragmentMerger;

package/dist/src/chunking/ImportOnlyFilter.d.ts

@@ -0,0 +1,5 @@
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { ChunkContext, IChunkPostProcessor } from './interfaces';
+export declare class ImportOnlyFilter implements IChunkPostProcessor {
+    process(pieces: ChunkPiece[], ctx: ChunkContext): ChunkPiece[];
+}