circuitscript 0.1.19 → 0.1.22

package/dist/cjs/visitor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisitorExecutionException = exports.ParserVisitor = void 0;
+exports.VisitorExecutionException = exports.ComponentRefDesPrefixes = exports.ParserVisitor = void 0;
 const ClassComponent_js_1 = require("./objects/ClassComponent.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const PinDefinition_js_1 = require("./objects/PinDefinition.js");
@@ -13,9 +13,11 @@ const BaseVisitor_js_1 = require("./BaseVisitor.js");
 const utils_js_2 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
 const Frame_js_1 = require("./objects/Frame.js");
+const ComponentAnnotater_js_1 = require("./ComponentAnnotater.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
+        this.componentCreationIndex = 0;
         this.visitKeyword_assignment_expr = (ctx) => {
             const id = ctx.ID().getText();
             const value = this.visitResult(ctx.data_expr());
@@ -40,28 +42,53 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             this.setResult(ctx, pinId);
         };
+        this.trackNewComponentCreated = (callback) => {
+            const preCreatedIndex = this.componentCreationIndex;
+            callback();
+            const postCreatedIndex = this.componentCreationIndex;
+            let creationFlag = false;
+            if (postCreatedIndex > preCreatedIndex) {
+                creationFlag = true;
+            }
+            return creationFlag;
+        };
         this.visitAdd_component_expr = (ctx) => {
-            const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
-            this.getExecutor().addComponentExisting(component, pinValue);
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
+                this.getExecutor().addComponentExisting(component, pinValue);
+                refComponent = component;
+            });
+            this.linkComponentToCtx(ctx, refComponent, creationFlag);
         };
         this.visitAt_component_expr = (ctx) => {
-            const [component, pin] = this.visitResult(ctx.component_select_expr());
-            this.getExecutor().atComponent(component, pin, {
-                addSequence: true
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pin] = this.visitResult(ctx.component_select_expr());
+                this.getExecutor().atComponent(component, pin, {
+                    addSequence: true
+                });
+                refComponent = component;
             });
+            this.linkComponentToCtx(ctx, refComponent, creationFlag);
             return this.getExecutor().getCurrentPoint();
         };
         this.visitTo_component_expr = (ctx) => {
             ctx.component_select_expr().forEach(item => {
-                const [component, pin] = this.visitResult(item);
-                try {
-                    this.getExecutor().toComponent(component, pin, {
-                        addSequence: true
-                    });
-                }
-                catch (err) {
-                    throw new utils_js_2.RuntimeExecutionError(err.message, ctx);
-                }
+                let refComponent;
+                const creationFlag = this.trackNewComponentCreated(() => {
+                    const [component, pin] = this.visitResult(item);
+                    try {
+                        this.getExecutor().toComponent(component, pin, {
+                            addSequence: true
+                        });
+                        refComponent = component;
+                    }
+                    catch (err) {
+                        throw new utils_js_2.RuntimeExecutionError(err.message, ctx);
+                    }
+                });
+                this.linkComponentToCtx(item, refComponent, creationFlag);
             });
             return this.getExecutor().getCurrentPoint();
         };
@@ -332,6 +359,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             try {
                 const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
                 this.setResult(ctx, createdComponent);
+                createdComponent._creationIndex = this.componentCreationIndex++;
             }
             catch (error) {
                 this.throwWithContext(ctx, error.message);
@@ -822,7 +850,28 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const resolveNet = this.createNetResolver(this.executionStack);
             const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
             const __runFunc = (passedInParameters, options) => {
-                const executionContextName = `${functionName}-${functionCounter['counter']}`;
+                const executor = this.getExecutor();
+                const parentBreakContext = executor.getParentBreakContext();
+                executor.addBreakContext(ctx);
+                let useIndex = -1;
+                if (parentBreakContext === null) {
+                    useIndex = options.functionCallIndex;
+                }
+                else {
+                    const parentEntry = executor.indexedStack.get(parentBreakContext);
+                    const { funcCallIndex } = parentEntry;
+                    if (!funcCallIndex.has(ctx)) {
+                        funcCallIndex.set(ctx, 0);
+                        useIndex = 0;
+                    }
+                    else {
+                        useIndex = funcCallIndex.get(ctx) + 1;
+                        funcCallIndex.set(ctx, useIndex);
+                    }
+                }
+                executor.setBreakContextIndex(useIndex);
+                const functionCounterIndex = functionCounter['counter'];
+                const executionContextName = `${functionName}-${functionCounterIndex}`;
                 const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
                 functionCounter['counter'] += 1;
                 newExecutor.resolveNet = resolveNet;
@@ -830,7 +879,23 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
                 const lastExecution = executionStack.pop();
                 const nextLastExecution = executionStack[executionStack.length - 1];
-                nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+                const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+                const scope = this.getScope();
+                const indexedStack = [];
+                if (scope.breakStack.length > 0) {
+                    const executor = this.getExecutor();
+                    scope.breakStack.forEach(stackCtx => {
+                        const entry = executor.indexedStack.get(stackCtx);
+                        const { index } = entry;
+                        indexedStack.push([stackCtx, index]);
+                    });
+                    mergedComponents.forEach(component => {
+                        component.ctxReferences.forEach(ref => {
+                            ref.indexedStack = [...indexedStack, ...ref.indexedStack];
+                        });
+                    });
+                }
+                executor.popBreakContext();
                 return [lastExecution, returnValue];
             };
             this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
@@ -874,10 +939,18 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             executor.log('end at block pin expressions');
             executor.atComponent(currentComponent, currentPin);
         };
+        this.visitAt_block_header = (ctx) => {
+            const ctxAtComponent = ctx.at_component_expr();
+            this.visit(ctxAtComponent);
+            const [currentComponent,] = this.getExecutor().getCurrentPoint();
+            this.componentCtxLinks.delete(ctxAtComponent);
+            this.componentCtxLinks.set(ctx, currentComponent);
+        };
         this.visitAt_block = (ctx) => {
             const executor = this.getExecutor();
             executor.log('entering at block');
-            this.visit(ctx.at_component_expr());
+            const ctxAtBlockComponent = ctx.at_block_header();
+            this.visit(ctxAtBlockComponent);
             const [currentComponent, currentPin] = executor.getCurrentPoint();
             executor.scope.scopeLevel += 1;
             ctx.at_block_expressions().forEach(expression => {
@@ -1037,10 +1110,14 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const dataExpr = ctx.data_expr();
             let keepLooping = true;
             this.log('enter while loop');
-            this.getExecutor().addBreakContext(ctx);
+            const executor = this.getExecutor();
+            executor.addBreakContext(ctx);
+            let counter = 0;
             while (keepLooping) {
                 const result = this.visitResult(dataExpr);
                 if (result) {
+                    executor.setBreakContextIndex(counter);
+                    executor.resetBreakContextFunctionCalls();
                     this.visit(ctx.expressions_block());
                     keepLooping = true;
                     const currentResult = this.getResult(ctx) ?? {};
@@ -1055,6 +1132,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                             continueSignal: false
                         });
                     }
+                    counter++;
                 }
                 else {
                     keepLooping = false;
@@ -1068,7 +1146,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const forVariableNames = ctx.ID().map(item => item.getText());
             let listItems = this.visitResult(ctx.data_expr());
             listItems = (0, utils_js_1.unwrapValue)(listItems);
-            this.getExecutor().addBreakContext(ctx);
+            const executor = this.getExecutor();
+            executor.addBreakContext(ctx);
             let keepLooping = true;
             let counter = 0;
             while (keepLooping) {
@@ -1080,6 +1159,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     useValueArray.forEach((value, index) => {
                         this.getScope().setVariable(forVariableNames[index], value);
                     });
+                    executor.setBreakContextIndex(counter);
+                    executor.resetBreakContextFunctionCalls();
                     this.visit(ctx.expressions_block());
                     keepLooping = true;
                     const currentResult = this.getResult(ctx) ?? {};
@@ -1101,7 +1182,19 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     keepLooping = false;
                 }
             }
-            this.getExecutor().popBreakContext();
+            executor.popBreakContext();
+        };
+        this.visitAnnotation_comment_expr = (ctx) => {
+            const refdesID = ctx.ID().getText();
+            const currentComponent = this.getScope().currentComponent;
+            if (currentComponent !== null) {
+                if (refdesID.indexOf('_') === -1) {
+                    currentComponent.setParam('refdes', refdesID);
+                }
+                else {
+                    currentComponent.placeHolderRefDes = refdesID;
+                }
+            }
         };
         this.pinTypes = [
             PinTypes_js_1.PinTypes.Any,
@@ -1346,7 +1439,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     }
     annotateComponents() {
         this.log('===== annotate components =====');
-        const annotater = new ComponentAnnotater();
+        const annotater = new ComponentAnnotater_js_1.ComponentAnnotater();
         const instances = this.getScope().instances;
         const toAnnotate = [];
         for (const [, instance] of instances) {
@@ -1355,8 +1448,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 continue;
             }
             if (instance.assignedRefDes === null) {
-                if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes');
+                if (instance.hasParam('refdes')) {
+                    const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
@@ -1368,10 +1461,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
         }
         toAnnotate.forEach(instance => {
-            const useTypeProp = instance.typeProp ?? 'conn';
-            instance.typeProp === null
-                && this.log('Instance has no type:', instance.instanceName, ' assuming connector');
-            const newRefDes = annotater.getAnnotation(useTypeProp);
+            const newRefDes = annotater.getAnnotation(instance);
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
@@ -1456,7 +1546,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     }
 }
 exports.ParserVisitor = ParserVisitor;
-const ComponentRefDesPrefixes = {
+exports.ComponentRefDesPrefixes = {
     res: 'R',
     cap: 'C',
     ind: 'L',
@@ -1467,48 +1557,6 @@ const ComponentRefDesPrefixes = {
     ic: 'U',
     '?': '?',
 };
-class ComponentAnnotater {
-    constructor() {
-        this.counter = {};
-        this.existingRefDes = [];
-        for (const key in ComponentRefDesPrefixes) {
-            this.counter[key] = 1;
-        }
-    }
-    getAnnotation(type) {
-        if (this.counter[type] === undefined && type.length <= 2) {
-            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
-                if (value === type) {
-                    throw "Refdes prefix is already in use!";
-                }
-            }
-            if (ComponentRefDesPrefixes[type] === undefined) {
-                ComponentRefDesPrefixes[type] = type;
-                this.counter[type] = 1;
-            }
-        }
-        if (ComponentRefDesPrefixes[type] === undefined) {
-            return null;
-        }
-        let attempts = 100;
-        let proposedName = "";
-        while (attempts >= 0) {
-            proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
-            this.counter[type]++;
-            if (this.existingRefDes.indexOf(proposedName) === -1) {
-                break;
-            }
-            attempts--;
-        }
-        if (attempts === 0) {
-            throw "Annotation failed!";
-        }
-        return proposedName;
-    }
-    trackRefDes(name) {
-        this.existingRefDes.push(name);
-    }
-}
 class VisitorExecutionException {
     constructor(context, errorMessage) {
         this.errorMessage = errorMessage;

package/dist/esm/BaseVisitor.js

@@ -23,6 +23,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
     acceptedDirections = [Direction.Up, Direction.Down,
         Direction.Right, Direction.Left];
     resultData = new Map;
+    componentCtxLinks = new Map;
     pinTypesList = [
         PinTypes.Any,
         PinTypes.Input,
@@ -564,6 +565,27 @@ export class BaseVisitor extends CircuitScriptVisitor {
     getResult(ctx) {
         return this.resultData.get(ctx);
     }
+    linkComponentToCtx(ctx, instance, creationFlag = true) {
+        const scope = this.getScope();
+        const indexedStack = [];
+        if (scope.breakStack.length > 0) {
+            const executor = this.getExecutor();
+            scope.breakStack.forEach(stackCtx => {
+                const entry = executor.indexedStack.get(stackCtx);
+                const { index } = entry;
+                indexedStack.push([stackCtx, index]);
+            });
+        }
+        instance.ctxReferences.push({
+            ctx,
+            indexedStack,
+            creationFlag
+        });
+        this.componentCtxLinks.set(ctx, instance);
+    }
+    getComponentCtxLinks() {
+        return this.componentCtxLinks;
+    }
     visitResult(ctx) {
         this.visit(ctx);
         return this.getResult(ctx);

package/dist/esm/ComponentAnnotater.js

@@ -0,0 +1,84 @@
+import { ComponentRefDesPrefixes } from './visitor.js';
+export class ComponentAnnotater {
+    counter = {};
+    indexedContextPrefix = new Map();
+    existingRefDes = [];
+    constructor() {
+        for (const key in ComponentRefDesPrefixes) {
+            this.counter[key] = 1;
+        }
+    }
+    getAnnotation(instance) {
+        const type = instance.typeProp ?? 'conn';
+        if (this.counter[type] === undefined && type.length <= 2) {
+            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
+                if (value === type) {
+                    throw "Refdes prefix is already in use!";
+                }
+            }
+            if (ComponentRefDesPrefixes[type] === undefined) {
+                ComponentRefDesPrefixes[type] = type;
+                this.counter[type] = 1;
+            }
+        }
+        if (ComponentRefDesPrefixes[type] === undefined) {
+            return null;
+        }
+        let prefix = '';
+        let resultRefdes = '';
+        const { ctxReferences } = instance;
+        if (ctxReferences.length > 0) {
+            const firstReference = ctxReferences[0];
+            const { ctx: useCtx, indexedStack, creationFlag } = firstReference;
+            if (indexedStack.length > 0 && creationFlag) {
+                const indexes = indexedStack.map(item => {
+                    return item[1] + 1;
+                });
+                if (!this.indexedContextPrefix.has(useCtx)) {
+                    if (instance.placeHolderRefDes) {
+                        prefix = instance.placeHolderRefDes.replaceAll('_', '');
+                    }
+                    else {
+                        const { index: nextIndex, proposedName } = this.getNextRefdesCounter(ComponentRefDesPrefixes[type], this.counter[type]);
+                        this.counter[type] = nextIndex;
+                        prefix = proposedName;
+                    }
+                    this.existingRefDes.push(prefix);
+                    this.indexedContextPrefix.set(useCtx, prefix);
+                }
+                const prefixParts = [this.indexedContextPrefix.get(useCtx), ...indexes];
+                resultRefdes = prefixParts.join('_');
+                if (this.existingRefDes.indexOf(resultRefdes) !== -1) {
+                    console.log('Warning: Refdes already used:', resultRefdes);
+                }
+            }
+            else {
+                const refdesCounter = this.getNextRefdesCounter(ComponentRefDesPrefixes[type], this.counter[type]);
+                this.counter[type] = refdesCounter.index;
+                resultRefdes = refdesCounter.proposedName;
+            }
+            this.existingRefDes.push(resultRefdes);
+            return resultRefdes;
+        }
+    }
+    getNextRefdesCounter(prefix, startingIndex) {
+        let attempts = 100;
+        let proposedName = "";
+        let index = startingIndex;
+        while (attempts >= 0) {
+            proposedName = prefix + index;
+            index++;
+            if (this.existingRefDes.indexOf(proposedName) === -1) {
+                break;
+            }
+            attempts--;
+        }
+        if (attempts === 0) {
+            throw "Annotation failed";
+        }
+        return { index, proposedName };
+    }
+    trackRefDes(name) {
+        this.existingRefDes.push(name);
+    }
+}

package/dist/esm/RefdesAnnotationVisitor.js

@@ -0,0 +1,196 @@
+import { CircuitScriptParser } from './antlr/CircuitScriptParser.js';
+import { BaseVisitor } from './BaseVisitor.js';
+export class RefdesAnnotationVisitor extends BaseVisitor {
+    sourceText;
+    tokenStream;
+    modifications = new Map();
+    resultText = '';
+    debug = false;
+    componentCtxLinks;
+    constructor(silent, sourceText, tokenStream, componentCtxLinks) {
+        super(true);
+        this.sourceText = sourceText;
+        this.tokenStream = tokenStream;
+        this.componentCtxLinks = componentCtxLinks;
+    }
+    getOriginalText(ctx) {
+        if (!ctx.start || !ctx.stop) {
+            return '';
+        }
+        const startIndex = ctx.start.start;
+        const stopIndex = ctx.stop.stop;
+        return this.sourceText.substring(startIndex, stopIndex + 1);
+    }
+    visitScript = async (ctx) => {
+        const result = this.runExpressions(this.getExecutor(), ctx.expression());
+        this.setResult(ctx, result);
+        this.getExecutor().closeOpenPathBlocks();
+        this.resultText = this.generateModifiedText();
+    };
+    visitAdd_component_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_component_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitComponent_select_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_block_header = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_block = (ctx) => {
+        this.visit(ctx.at_block_header());
+        ctx.at_block_expressions().forEach(expression => {
+            this.visit(expression);
+        });
+    };
+    visitTo_component_expr = (ctx) => {
+        const allRefdes = [];
+        ctx.component_select_expr().forEach(itemCtx => {
+            const tmpRefdes = this.generateRefdesAnnotationComment(itemCtx);
+            if (tmpRefdes !== null) {
+                allRefdes.push(tmpRefdes);
+            }
+        });
+        if (allRefdes.length > 0) {
+            const originalText = this.getOriginalText(ctx);
+            const annotation = ' #= ' + allRefdes.join(',');
+            this.modifications.set(ctx, originalText + annotation);
+        }
+    };
+    visitFunction_def_expr = (ctx) => {
+        this.runExpressions(this.getExecutor(), ctx.function_expr());
+    };
+    visitFunction_return_expr = (ctx) => {
+    };
+    visitFrame_expr = (ctx) => {
+        this.visit(ctx.expressions_block());
+    };
+    visitFunction_call_expr = (ctx) => {
+    };
+    visitParameters = (ctx) => {
+    };
+    addedRefdesAnnotations = [];
+    generateRefdesAnnotationComment(ctx) {
+        if (this.componentCtxLinks.has(ctx)) {
+            const instance = this.componentCtxLinks.get(ctx);
+            const alreadyHaveRefdesAnnotation = instance.assignedRefDes !== null ?
+                (this.addedRefdesAnnotations.indexOf(instance.assignedRefDes) !== -1) : false;
+            if (!instance.hasParam('refdes')
+                && instance.placeHolderRefDes === null
+                && instance.assignedRefDes
+                && !alreadyHaveRefdesAnnotation) {
+                let useRefDes = instance.assignedRefDes;
+                let isPlaceholderRefdes = false;
+                const { ctxReferences } = instance;
+                if (ctxReferences.length > 0) {
+                    const firstReference = ctxReferences[0];
+                    const { indexedStack: loopStack = [] } = firstReference;
+                    if (loopStack.length > 0) {
+                        isPlaceholderRefdes = true;
+                        const parts = instance.assignedRefDes.split('_');
+                        useRefDes = parts[0] + '_';
+                    }
+                    if (this.addedRefdesAnnotations.indexOf(instance.assignedRefDes) === -1
+                        && !isPlaceholderRefdes) {
+                        this.addedRefdesAnnotations.push(instance.assignedRefDes);
+                    }
+                    return useRefDes;
+                }
+            }
+        }
+        return null;
+    }
+    addRefdesAnnotationComment(ctx) {
+        const refdes = this.generateRefdesAnnotationComment(ctx);
+        if (refdes !== null) {
+            const originalText = this.getOriginalText(ctx);
+            const annotation = ' #= ' + refdes;
+            this.modifications.set(ctx, originalText + annotation);
+        }
+    }
+    getOutput() {
+        return this.resultText;
+    }
+    generateModifiedText() {
+        const output = [];
+        const allTokens = this.tokenStream.getTokens();
+        const processedTokens = new Set();
+        let lastSourcePos = 0;
+        const contextTokenRanges = this.buildContextTokenRanges();
+        for (let i = 0; i < allTokens.length; i++) {
+            const token = allTokens[i];
+            if (processedTokens.has(i)) {
+                continue;
+            }
+            const tokenText = this.sourceText.substring(token.start, token.stop + 1);
+            this.log(i, `token: [${tokenText}], length: ${tokenText.length}, text: [${token.text}]`);
+            if (token.type === CircuitScriptParser.DEDENT
+                || token.type === CircuitScriptParser.EOF
+                || (token.type === CircuitScriptParser.NEWLINE && token.__skip)) {
+                this.log('--skip dedent/EOF token');
+                continue;
+            }
+            const ctx = this.findContextForToken(token, contextTokenRanges);
+            if (ctx) {
+                const isFirstTokenInContext = token.tokenIndex === ctx.start?.tokenIndex;
+                if (isFirstTokenInContext) {
+                    if (token.start > lastSourcePos) {
+                        output.push(this.sourceText.substring(lastSourcePos, token.start));
+                    }
+                    if (this.modifications.has(ctx)) {
+                        output.push(this.modifications.get(ctx));
+                        this.markTokensAsProcessed(ctx, processedTokens);
+                        if (ctx.stop) {
+                            lastSourcePos = ctx.stop.stop + 1;
+                        }
+                        continue;
+                    }
+                }
+            }
+            if (token.start > lastSourcePos) {
+                output.push(this.sourceText.substring(lastSourcePos, token.start));
+            }
+            if (tokenText.length > 0) {
+                output.push(tokenText);
+            }
+            processedTokens.add(i);
+            lastSourcePos = token.stop + 1;
+        }
+        if (lastSourcePos < this.sourceText.length) {
+            output.push(this.sourceText.substring(lastSourcePos));
+        }
+        return output.join('');
+    }
+    buildContextTokenRanges() {
+        const ranges = new Map();
+        for (const ctx of this.modifications.keys()) {
+            if (ctx.start && ctx.stop) {
+                ranges.set(ctx, [ctx.start.tokenIndex, ctx.stop.tokenIndex]);
+            }
+        }
+        return ranges;
+    }
+    findContextForToken(token, contextRanges) {
+        for (const [ctx, [start, end]] of contextRanges) {
+            if (token.tokenIndex >= start && token.tokenIndex <= end) {
+                return ctx;
+            }
+        }
+        return null;
+    }
+    markTokensAsProcessed(ctx, processedTokens) {
+        if (!ctx.start || !ctx.stop) {
+            return;
+        }
+        for (let i = ctx.start.tokenIndex; i <= ctx.stop.tokenIndex; i++) {
+            processedTokens.add(i);
+        }
+    }
+    log(...message) {
+        if (this.debug) {
+            console.log(...message);
+        }
+    }
+}