norn-cli 2.4.0 → 2.6.0

package/out/debug/nornDebugSession.js

@@ -1,613 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NornDebugSession = void 0;
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const parser_1 = require("../parser");
-const sequenceRunner_1 = require("../sequenceRunner");
-const responsePanel_1 = require("../responsePanel");
-const environmentProvider_1 = require("../environmentProvider");
-const formatError_1 = require("../errors/formatError");
-const importErrors_1 = require("../importErrors");
-const breakpointResolver_1 = require("./breakpointResolver");
-const sequenceLocationIndex_1 = require("./sequenceLocationIndex");
-const THREAD_ID = 1;
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
-}
-function formatVariableValue(value) {
-    if (value === null) {
-        return 'null';
-    }
-    if (value === undefined) {
-        return 'undefined';
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        return String(value);
-    }
-    if (Array.isArray(value)) {
-        return `Array(${value.length})`;
-    }
-    return 'Object';
-}
-class NornDebugSession {
-    send;
-    extensionUri;
-    outgoingSeq = 1;
-    launchConfig;
-    configurationDone = false;
-    launchStarted = false;
-    terminated = false;
-    breakpointsByFile = new Map();
-    continueMode = 'continue';
-    stepDepthTarget = 0;
-    pauseRequested = false;
-    waitForResume;
-    resumeResolver;
-    stopOnEntryConsumed = false;
-    frames = [];
-    nextFrameId = 1;
-    pausedState;
-    lastStepEvent;
-    failurePauseHandled = false;
-    runtimeVariables = {};
-    responses = [];
-    variableHandles = new Map();
-    nextVariableHandle = 1;
-    constructor(extensionUri, send) {
-        this.extensionUri = extensionUri;
-        this.send = send;
-    }
-    async handleRequest(request) {
-        try {
-            switch (request.command) {
-                case 'initialize':
-                    this.handleInitialize(request);
-                    return;
-                case 'launch':
-                    this.handleLaunch(request);
-                    return;
-                case 'setBreakpoints':
-                    await this.handleSetBreakpoints(request);
-                    return;
-                case 'configurationDone':
-                    this.handleConfigurationDone(request);
-                    return;
-                case 'threads':
-                    this.handleThreads(request);
-                    return;
-                case 'stackTrace':
-                    this.handleStackTrace(request);
-                    return;
-                case 'scopes':
-                    this.handleScopes(request);
-                    return;
-                case 'variables':
-                    this.handleVariables(request);
-                    return;
-                case 'continue':
-                    this.handleContinue(request);
-                    return;
-                case 'next':
-                    this.handleNext(request);
-                    return;
-                case 'stepIn':
-                    this.handleStepIn(request);
-                    return;
-                case 'stepOut':
-                    this.handleStepOut(request);
-                    return;
-                case 'pause':
-                    this.handlePause(request);
-                    return;
-                case 'disconnect':
-                case 'terminate':
-                    this.handleDisconnect(request);
-                    return;
-                default:
-                    this.sendErrorResponse(request, `Unsupported command: ${request.command}`);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.sendErrorResponse(request, message);
-        }
-    }
-    handleInitialize(request) {
-        this.sendResponse(request, {
-            supportsConfigurationDoneRequest: true,
-            supportsTerminateRequest: true,
-            supportsConditionalBreakpoints: false,
-            supportsHitConditionalBreakpoints: false,
-            supportsLogPoints: false
-        });
-        this.sendEvent('initialized');
-    }
-    handleLaunch(request) {
-        const config = request.arguments;
-        if (!config || !config.file || !config.sequence) {
-            this.sendErrorResponse(request, 'Launch requires file and sequence');
-            return;
-        }
-        this.launchConfig = {
-            ...config,
-            file: path.resolve(config.file),
-            stopOnEntry: config.stopOnEntry ?? true
-        };
-        this.sendResponse(request);
-        if (this.configurationDone && !this.launchStarted) {
-            this.startLaunch();
-        }
-    }
-    async handleSetBreakpoints(request) {
-        const args = request.arguments || {};
-        const sourcePath = typeof args?.source?.path === 'string' ? path.resolve(args.source.path) : undefined;
-        if (!sourcePath) {
-            this.sendResponse(request, { breakpoints: [] });
-            return;
-        }
-        const requestedLines = Array.isArray(args.lines)
-            ? args.lines
-            : Array.isArray(args.breakpoints)
-                ? args.breakpoints.map((bp) => bp?.line).filter((line) => typeof line === 'number')
-                : [];
-        const resolved = await (0, breakpointResolver_1.resolveBreakpointsForFile)(sourcePath, requestedLines);
-        const verified = new Set();
-        for (const item of resolved) {
-            if (item.verified) {
-                verified.add(item.line);
-            }
-        }
-        this.breakpointsByFile.set(sourcePath, verified);
-        this.sendResponse(request, {
-            breakpoints: resolved.map(item => ({
-                verified: item.verified,
-                line: item.line,
-                message: item.message
-            }))
-        });
-    }
-    handleConfigurationDone(request) {
-        this.configurationDone = true;
-        this.sendResponse(request);
-        if (this.launchConfig && !this.launchStarted) {
-            this.startLaunch();
-        }
-    }
-    handleThreads(request) {
-        this.sendResponse(request, {
-            threads: [{ id: THREAD_ID, name: 'Norn' }]
-        });
-    }
-    handleStackTrace(request) {
-        const ordered = [...this.frames].sort((a, b) => b.nestingDepth - a.nestingDepth);
-        const stackFrames = ordered.map(frame => {
-            const lineZero = frame.currentLine ?? frame.declarationLine ?? 0;
-            const sourcePath = frame.filePath;
-            return {
-                id: frame.id,
-                name: frame.sequenceName,
-                source: sourcePath
-                    ? { name: path.basename(sourcePath), path: sourcePath }
-                    : undefined,
-                line: lineZero + 1,
-                column: 1
-            };
-        });
-        this.sendResponse(request, {
-            stackFrames,
-            totalFrames: stackFrames.length
-        });
-    }
-    handleScopes(request) {
-        const runtimeRef = this.createVariableReference(this.runtimeVariables);
-        const responsesObject = {};
-        this.responses.forEach((resp, idx) => {
-            responsesObject[`$${idx + 1}`] = resp;
-        });
-        const responsesRef = this.createVariableReference(responsesObject);
-        this.sendResponse(request, {
-            scopes: [
-                {
-                    name: 'Runtime Variables',
-                    variablesReference: runtimeRef,
-                    expensive: false
-                },
-                {
-                    name: 'Responses',
-                    variablesReference: responsesRef,
-                    expensive: false
-                }
-            ]
-        });
-    }
-    handleVariables(request) {
-        const args = request.arguments || {};
-        const handle = typeof args.variablesReference === 'number' ? args.variablesReference : 0;
-        const value = this.variableHandles.get(handle);
-        if (value === undefined) {
-            this.sendResponse(request, { variables: [] });
-            return;
-        }
-        const variables = [];
-        if (Array.isArray(value)) {
-            value.forEach((item, idx) => {
-                variables.push({
-                    name: String(idx),
-                    value: formatVariableValue(item),
-                    variablesReference: this.createVariableReference(item),
-                    type: Array.isArray(item) ? 'array' : typeof item
-                });
-            });
-        }
-        else if (isObjectLike(value)) {
-            for (const [key, item] of Object.entries(value)) {
-                variables.push({
-                    name: key,
-                    value: formatVariableValue(item),
-                    variablesReference: this.createVariableReference(item),
-                    type: Array.isArray(item) ? 'array' : typeof item
-                });
-            }
-        }
-        this.sendResponse(request, { variables });
-    }
-    handleContinue(request) {
-        this.continueMode = 'continue';
-        this.resumeExecution();
-        this.sendResponse(request, { allThreadsContinued: true });
-    }
-    handleNext(request) {
-        this.continueMode = 'next';
-        this.stepDepthTarget = Math.max(1, this.frames.length);
-        this.resumeExecution();
-        this.sendResponse(request);
-    }
-    handleStepIn(request) {
-        this.continueMode = 'stepIn';
-        this.resumeExecution();
-        this.sendResponse(request);
-    }
-    handleStepOut(request) {
-        this.continueMode = 'stepOut';
-        this.stepDepthTarget = Math.max(0, this.frames.length - 1);
-        this.resumeExecution();
-        this.sendResponse(request);
-    }
-    handlePause(request) {
-        this.pauseRequested = true;
-        this.sendResponse(request);
-    }
-    handleDisconnect(request) {
-        this.terminated = true;
-        this.resumeExecution();
-        this.sendResponse(request);
-        this.sendEvent('terminated');
-    }
-    createVariableReference(value) {
-        if (!isObjectLike(value) && !Array.isArray(value)) {
-            return 0;
-        }
-        const handle = this.nextVariableHandle++;
-        this.variableHandles.set(handle, value);
-        return handle;
-    }
-    resetVariableHandles() {
-        this.variableHandles.clear();
-        this.nextVariableHandle = 1;
-    }
-    startLaunch() {
-        if (this.launchStarted) {
-            return;
-        }
-        this.launchStarted = true;
-        void this.runLaunch();
-    }
-    async runLaunch() {
-        if (!this.launchConfig) {
-            return;
-        }
-        this.sendEvent('thread', { reason: 'started', threadId: THREAD_ID });
-        const config = this.launchConfig;
-        const previousEnv = (0, environmentProvider_1.getActiveEnvironment)(config.file);
-        try {
-            await this.validateEnvironmentSelection(config.file, config.env);
-            if (config.env) {
-                (0, environmentProvider_1.setActiveEnvironment)(config.env, config.file);
-            }
-            await this.ensureEnvironmentReady(config.file);
-            const fileContent = await fs.readFile(config.file, 'utf-8');
-            const importResult = await (0, parser_1.resolveImports)(fileContent, path.dirname(config.file), async (importPath) => fs.readFile(importPath, 'utf-8'), undefined, undefined, config.file);
-            const duplicateErrors = (0, importErrors_1.getBlockingImportErrors)(importResult.errors);
-            if (duplicateErrors.length > 0) {
-                throw new Error(`Cannot debug sequence due to blocking import errors: ${duplicateErrors[0].error}`);
-            }
-            const fullTextWithImports = importResult.importedContent
-                ? `${importResult.importedContent}\n\n${fileContent}`
-                : fileContent;
-            const sequence = (0, sequenceRunner_1.extractSequences)(fullTextWithImports).find(seq => seq.name === config.sequence);
-            if (!sequence) {
-                throw new Error(`Sequence '${config.sequence}' not found`);
-            }
-            const locationIndex = await (0, sequenceLocationIndex_1.buildSequenceLocationIndex)(config.file, importResult.sequenceSources);
-            const location = locationIndex.get(sequence.name.toLowerCase());
-            const envVars = (0, environmentProvider_1.getEnvironmentVariables)(config.file);
-            const fileVariables = (0, parser_1.extractFileLevelVariables)(fileContent);
-            const allVariables = (0, parser_1.attachEnvironmentScope)({ ...envVars, ...fileVariables }, envVars);
-            const defaultArgs = {};
-            if (sequence.parameters) {
-                for (const param of sequence.parameters) {
-                    if (param.defaultValue !== undefined) {
-                        defaultArgs[param.name] = param.defaultValue;
-                    }
-                }
-            }
-            const runArgs = { ...defaultArgs, ...(config.args || {}) };
-            const apiDefinitions = (importResult.headerGroups?.length || 0) > 0 || (importResult.endpoints?.length || 0) > 0
-                ? { headerGroups: importResult.headerGroups || [], endpoints: importResult.endpoints || [] }
-                : undefined;
-            const envValidationContext = this.getEnvironmentValidationContext(config.file);
-            const executionContext = {
-                filePath: location?.filePath ?? config.file,
-                sequenceName: sequence.name,
-                environment: envValidationContext,
-                sequenceStartLine: location?.startLine ?? sequence.startLine,
-                sequenceLocationIndex: locationIndex
-            };
-            this.frames = [];
-            this.pauseRequested = false;
-            this.stopOnEntryConsumed = false;
-            this.failurePauseHandled = false;
-            this.runtimeVariables = allVariables;
-            this.responses = [];
-            responsePanel_1.ResponsePanel.startSequenceRun(this.extensionUri, sequence.name, (0, sequenceRunner_1.countSequenceSteps)(sequence.content), config.file);
-            const debugHooks = {
-                onSequenceEnter: (info) => this.onSequenceEnter(info),
-                onSequenceExit: (info) => this.onSequenceExit(info),
-                beforeStep: (event) => this.onBeforeStep(event),
-                onFailure: async (failure) => {
-                    const event = this.lastStepEvent;
-                    if (!event) {
-                        return;
-                    }
-                    this.failurePauseHandled = true;
-                    await this.pauseExecution('exception', event, failure.message);
-                }
-            };
-            const result = await (0, sequenceRunner_1.runSequence)(sequence.content, allVariables, path.dirname(config.file), fullTextWithImports, (progress) => this.onProgress(progress), undefined, runArgs, apiDefinitions, undefined, importResult.sequenceSources, importResult.sqlOperationsBySource, executionContext, debugHooks);
-            result.name = sequence.name;
-            responsePanel_1.ResponsePanel.finalizeSequence(result);
-            if (!result.success && this.lastStepEvent && !this.pausedState && !this.failurePauseHandled) {
-                await this.pauseExecution('exception', this.lastStepEvent, result.errors[0] || 'Sequence failed');
-            }
-        }
-        catch (error) {
-            const message = (0, formatError_1.formatUserFacingError)(error, {
-                source: 'extension',
-                filePath: this.launchConfig.file,
-                sequenceName: this.launchConfig.sequence,
-                environment: this.getEnvironmentValidationContext(this.launchConfig.file)
-            });
-            this.sendEvent('output', {
-                category: 'stderr',
-                output: `Norn debug error: ${message}\n`
-            });
-            responsePanel_1.ResponsePanel.finalizeSequence({
-                name: this.launchConfig.sequence,
-                success: false,
-                responses: [],
-                scriptResults: [],
-                assertionResults: [],
-                steps: [],
-                errors: [message],
-                duration: 0
-            });
-        }
-        finally {
-            if (config.env) {
-                (0, environmentProvider_1.setActiveEnvironment)(previousEnv, config.file);
-            }
-            this.sendEvent('thread', { reason: 'exited', threadId: THREAD_ID });
-            this.sendEvent('terminated');
-        }
-    }
-    getEnvironmentValidationContext(filePath) {
-        return {
-            hasEnvFile: (0, environmentProvider_1.getAvailableEnvironments)(filePath).length > 0,
-            activeEnvironment: (0, environmentProvider_1.getActiveEnvironment)(filePath),
-            availableEnvironments: (0, environmentProvider_1.getAvailableEnvironments)(filePath)
-        };
-    }
-    async validateEnvironmentSelection(filePath, env) {
-        if (!env) {
-            return;
-        }
-        const available = (0, environmentProvider_1.getAvailableEnvironments)(filePath);
-        if (!available.includes(env)) {
-            throw new Error(`Environment '${env}' not found. Available: ${available.join(', ') || 'none'}`);
-        }
-    }
-    async ensureEnvironmentReady(filePath) {
-        const envErrors = (0, environmentProvider_1.getEnvironmentImportErrorDetails)(filePath);
-        if (envErrors.length > 0) {
-            throw new Error(`.nornenv has errors: ${envErrors[0].message}`);
-        }
-        const unlocked = await (0, environmentProvider_1.promptForMissingEnvironmentSecretKeys)(filePath);
-        if (!unlocked) {
-            throw new Error('Secrets are locked. Enter shared key to continue.');
-        }
-        const secretErrors = (0, environmentProvider_1.getEnvironmentSecretErrorDetails)(filePath);
-        if (secretErrors.length > 0) {
-            throw new Error(`.nornenv secret error: ${secretErrors[0].message}`);
-        }
-    }
-    onProgress(progress) {
-        const prefix = progress.nestingDepth && progress.nestingDepth > 0 ? `${'  '.repeat(progress.nestingDepth)}` : '';
-        this.sendEvent('output', {
-            category: 'console',
-            output: `${prefix}[${progress.currentStep}/${progress.totalSteps}] ${progress.stepDescription}\n`
-        });
-        if (progress.stepType === 'sequenceStart' || progress.stepType === 'sequenceEnd') {
-            responsePanel_1.ResponsePanel.addSequenceStep(undefined, progress);
-        }
-        else if (progress.stepResult) {
-            responsePanel_1.ResponsePanel.addSequenceStep(progress.stepResult, progress);
-        }
-    }
-    async onSequenceEnter(info) {
-        const frame = {
-            id: this.nextFrameId++,
-            sequenceName: info.sequenceName || 'sequence',
-            filePath: info.filePath,
-            declarationLine: info.declarationLine,
-            currentLine: info.declarationLine,
-            nestingDepth: info.nestingDepth
-        };
-        this.frames.push(frame);
-    }
-    async onSequenceExit(info) {
-        while (this.frames.length > info.nestingDepth) {
-            this.frames.pop();
-        }
-    }
-    async onBeforeStep(event) {
-        if (this.terminated) {
-            throw new Error('Debug session terminated');
-        }
-        this.lastStepEvent = event;
-        this.runtimeVariables = event.runtimeVariables;
-        this.responses = event.responses;
-        const currentFrame = this.frames[this.frames.length - 1];
-        if (currentFrame && event.location.absoluteLine !== undefined) {
-            currentFrame.currentLine = event.location.absoluteLine;
-        }
-        const currentDepth = Math.max(1, this.frames.length);
-        let reason;
-        if (!this.stopOnEntryConsumed && (this.launchConfig?.stopOnEntry ?? true)) {
-            reason = 'entry';
-            this.stopOnEntryConsumed = true;
-        }
-        else if (this.pauseRequested) {
-            reason = 'pause';
-            this.pauseRequested = false;
-        }
-        else if (this.continueMode === 'stepIn') {
-            reason = 'step';
-        }
-        else if (this.continueMode === 'next' && currentDepth <= this.stepDepthTarget) {
-            reason = 'step';
-        }
-        else if (this.continueMode === 'stepOut' && currentDepth <= this.stepDepthTarget) {
-            reason = 'step';
-        }
-        else if (event.location.filePath && event.location.absoluteLine !== undefined) {
-            const filePath = path.resolve(event.location.filePath);
-            const lineOneBased = event.location.absoluteLine + 1;
-            const fileBreakpoints = this.breakpointsByFile.get(filePath);
-            if (fileBreakpoints && fileBreakpoints.has(lineOneBased)) {
-                reason = 'breakpoint';
-            }
-        }
-        if (!reason) {
-            return;
-        }
-        await this.pauseExecution(reason, event);
-    }
-    async pauseExecution(reason, event, message) {
-        if (this.terminated) {
-            throw new Error('Debug session terminated');
-        }
-        this.pausedState = { reason, event, message };
-        this.resetVariableHandles();
-        this.sendEvent('stopped', {
-            reason,
-            threadId: THREAD_ID,
-            description: message,
-            allThreadsStopped: true
-        });
-        this.waitForResume = new Promise((resolve) => {
-            this.resumeResolver = resolve;
-        });
-        await this.waitForResume;
-        this.waitForResume = undefined;
-        this.resumeResolver = undefined;
-        this.pausedState = undefined;
-        if (this.terminated) {
-            throw new Error('Debug session terminated');
-        }
-    }
-    resumeExecution() {
-        if (this.resumeResolver) {
-            this.resumeResolver();
-        }
-    }
-    sendResponse(request, body) {
-        const response = {
-            seq: this.outgoingSeq++,
-            type: 'response',
-            request_seq: request.seq,
-            command: request.command,
-            success: true,
-            body
-        };
-        this.send(response);
-    }
-    sendErrorResponse(request, message) {
-        const response = {
-            seq: this.outgoingSeq++,
-            type: 'response',
-            request_seq: request.seq,
-            command: request.command,
-            success: false,
-            message
-        };
-        this.send(response);
-    }
-    sendEvent(event, body) {
-        const output = {
-            seq: this.outgoingSeq++,
-            type: 'event',
-            event,
-            body
-        };
-        this.send(output);
-    }
-}
-exports.NornDebugSession = NornDebugSession;
-//# sourceMappingURL=nornDebugSession.js.map

package/out/debug/sequenceLocationIndex.js

@@ -1,77 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSequenceLocationIndex = buildSequenceLocationIndex;
-const fs = __importStar(require("fs/promises"));
-const sequenceRunner_1 = require("../sequenceRunner");
-const sequenceDeclaration_1 = require("../sequenceDeclaration");
-async function indexFile(filePath, index, readFile, visited) {
-    if (visited.has(filePath)) {
-        return;
-    }
-    visited.add(filePath);
-    const content = await readFile(filePath);
-    const lines = content.split('\n');
-    const sequences = (0, sequenceRunner_1.extractSequences)(content);
-    for (const seq of sequences) {
-        const key = seq.name.toLowerCase();
-        if (index.has(key)) {
-            continue;
-        }
-        const declarationLine = (0, sequenceDeclaration_1.findSequenceDeclarationLine)(lines, seq.startLine, seq.endLine);
-        const entry = {
-            filePath,
-            sequenceName: seq.name,
-            declarationLine,
-            startLine: declarationLine,
-            endLine: seq.endLine
-        };
-        index.set(key, entry);
-    }
-}
-/**
- * Builds a sequence location index for root file and imported sequence sources.
- */
-async function buildSequenceLocationIndex(rootFilePath, importedSequenceSources, readFile = (p) => fs.readFile(p, 'utf-8')) {
-    const index = new Map();
-    const visited = new Set();
-    await indexFile(rootFilePath, index, readFile, visited);
-    const importedFiles = new Set(Array.from(importedSequenceSources.values()));
-    for (const filePath of importedFiles) {
-        await indexFile(filePath, index, readFile, visited);
-    }
-    return index;
-}
-//# sourceMappingURL=sequenceLocationIndex.js.map

package/out/debug/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map