circuitscript 0.3.2 → 0.4.1

package/dist/types/antlr/{CircuitScriptVisitor.d.ts → CircuitScriptParserVisitor.d.ts}

@@ -3,78 +3,58 @@ import { ScriptContext } from "./CircuitScriptParser.js";
 import { ExpressionContext } from "./CircuitScriptParser.js";
 import { Flow_expressionsContext } from "./CircuitScriptParser.js";
 import { Graph_expressionsContext } from "./CircuitScriptParser.js";
-import { Graph_linear_expressionContext } from "./CircuitScriptParser.js";
 import { Expressions_blockContext } from "./CircuitScriptParser.js";
 import { Path_blockContext } from "./CircuitScriptParser.js";
-import { Property_set_expr2Context } from "./CircuitScriptParser.js";
-import { Assignment_expr2Context } from "./CircuitScriptParser.js";
 import { Pin_select_exprContext } from "./CircuitScriptParser.js";
 import { Component_modifier_exprContext } from "./CircuitScriptParser.js";
 import { Data_expr_with_assignmentContext } from "./CircuitScriptParser.js";
+import { Assignment_exprContext } from "./CircuitScriptParser.js";
 import { Add_component_exprContext } from "./CircuitScriptParser.js";
 import { Component_select_exprContext } from "./CircuitScriptParser.js";
-import { Pin_select_expr2Context } from "./CircuitScriptParser.js";
 import { At_component_exprContext } from "./CircuitScriptParser.js";
 import { To_component_exprContext } from "./CircuitScriptParser.js";
-import { At_to_multiple_exprContext } from "./CircuitScriptParser.js";
-import { At_to_multiple_line_exprContext } from "./CircuitScriptParser.js";
-import { At_to_multiple_line_expr_to_pinContext } from "./CircuitScriptParser.js";
+import { At_block_headerContext } from "./CircuitScriptParser.js";
 import { At_blockContext } from "./CircuitScriptParser.js";
 import { At_block_expressionsContext } from "./CircuitScriptParser.js";
-import { At_block_headerContext } from "./CircuitScriptParser.js";
 import { At_block_pin_exprContext } from "./CircuitScriptParser.js";
-import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser.js";
-import { At_block_pin_expression_complexContext } from "./CircuitScriptParser.js";
-import { Assignment_exprContext } from "./CircuitScriptParser.js";
-import { Operator_assignment_exprContext } from "./CircuitScriptParser.js";
 import { Keyword_assignment_exprContext } from "./CircuitScriptParser.js";
 import { ParametersContext } from "./CircuitScriptParser.js";
-import { Property_set_exprContext } from "./CircuitScriptParser.js";
 import { Double_dot_property_set_exprContext } from "./CircuitScriptParser.js";
+import { ValueExprContext } from "./CircuitScriptParser.js";
 import { ArrayExprContext } from "./CircuitScriptParser.js";
-import { ArrayIndexExprContext } from "./CircuitScriptParser.js";
-import { FunctionCallExprContext } from "./CircuitScriptParser.js";
 import { AdditionExprContext } from "./CircuitScriptParser.js";
 import { MultiplyExprContext } from "./CircuitScriptParser.js";
 import { LogicalOperatorExprContext } from "./CircuitScriptParser.js";
-import { DataExprContext } from "./CircuitScriptParser.js";
+import { CreateExprContext } from "./CircuitScriptParser.js";
 import { UnaryOperatorExprContext } from "./CircuitScriptParser.js";
-import { ValueAtomExprContext } from "./CircuitScriptParser.js";
+import { CallableExprContext } from "./CircuitScriptParser.js";
 import { BinaryOperatorExprContext } from "./CircuitScriptParser.js";
 import { RoundedBracketsExprContext } from "./CircuitScriptParser.js";
-import { Binary_operatorContext } from "./CircuitScriptParser.js";
-import { Unary_operatorContext } from "./CircuitScriptParser.js";
 import { Value_exprContext } from "./CircuitScriptParser.js";
 import { Function_def_exprContext } from "./CircuitScriptParser.js";
 import { Function_exprContext } from "./CircuitScriptParser.js";
 import { Function_args_exprContext } from "./CircuitScriptParser.js";
-import { Atom_exprContext } from "./CircuitScriptParser.js";
-import { Trailer_exprContext } from "./CircuitScriptParser.js";
-import { Trailer_expr2Context } from "./CircuitScriptParser.js";
-import { Function_call_exprContext } from "./CircuitScriptParser.js";
-import { Net_namespace_exprContext } from "./CircuitScriptParser.js";
 import { Function_return_exprContext } from "./CircuitScriptParser.js";
+import { Net_namespace_exprContext } from "./CircuitScriptParser.js";
+import { Callable_exprContext } from "./CircuitScriptParser.js";
+import { TrailerContext } from "./CircuitScriptParser.js";
 import { Property_block_exprContext } from "./CircuitScriptParser.js";
-import { Create_component_exprContext } from "./CircuitScriptParser.js";
+import { Properties_blockContext } from "./CircuitScriptParser.js";
 import { Graphic_expressions_blockContext } from "./CircuitScriptParser.js";
+import { Create_exprContext } from "./CircuitScriptParser.js";
+import { Create_component_exprContext } from "./CircuitScriptParser.js";
 import { Create_graphic_exprContext } from "./CircuitScriptParser.js";
 import { Create_module_exprContext } from "./CircuitScriptParser.js";
-import { Nested_properties_innerContext } from "./CircuitScriptParser.js";
-import { GraphicCommandExprContext } from "./CircuitScriptParser.js";
 import { GraphicForExprContext } from "./CircuitScriptParser.js";
+import { GraphicCommandExprContext } from "./CircuitScriptParser.js";
 import { Property_exprContext } from "./CircuitScriptParser.js";
 import { Property_key_exprContext } from "./CircuitScriptParser.js";
 import { Nested_propertiesContext } from "./CircuitScriptParser.js";
 import { Single_line_propertyContext } from "./CircuitScriptParser.js";
-import { Wire_expr_direction_valueContext } from "./CircuitScriptParser.js";
-import { Wire_expr_direction_onlyContext } from "./CircuitScriptParser.js";
 import { Wire_exprContext } from "./CircuitScriptParser.js";
-import { Array_exprContext } from "./CircuitScriptParser.js";
 import { Point_exprContext } from "./CircuitScriptParser.js";
 import { Import_simpleContext } from "./CircuitScriptParser.js";
-import { Import_all_simpleContext } from "./CircuitScriptParser.js";
-import { Import_specificContext } from "./CircuitScriptParser.js";
-import { Import_annotation_exprContext } from "./CircuitScriptParser.js";
+import { Import_specific_or_allContext } from "./CircuitScriptParser.js";
 import { Frame_exprContext } from "./CircuitScriptParser.js";
 import { If_exprContext } from "./CircuitScriptParser.js";
 import { If_inner_exprContext } from "./CircuitScriptParser.js";
@@ -86,86 +66,65 @@ import { Part_set_keyContext } from "./CircuitScriptParser.js";
 import { Part_match_blockContext } from "./CircuitScriptParser.js";
 import { Part_sub_exprContext } from "./CircuitScriptParser.js";
 import { Part_condition_exprContext } from "./CircuitScriptParser.js";
-import { Part_condition_key_only_exprContext } from "./CircuitScriptParser.js";
 import { Part_value_exprContext } from "./CircuitScriptParser.js";
 import { Annotation_comment_exprContext } from "./CircuitScriptParser.js";
-export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<Result> {
+export declare class CircuitScriptParserVisitor<Result> extends AbstractParseTreeVisitor<Result> {
     visitScript?: (ctx: ScriptContext) => Result;
     visitExpression?: (ctx: ExpressionContext) => Result;
     visitFlow_expressions?: (ctx: Flow_expressionsContext) => Result;
     visitGraph_expressions?: (ctx: Graph_expressionsContext) => Result;
-    visitGraph_linear_expression?: (ctx: Graph_linear_expressionContext) => Result;
     visitExpressions_block?: (ctx: Expressions_blockContext) => Result;
     visitPath_block?: (ctx: Path_blockContext) => Result;
-    visitProperty_set_expr2?: (ctx: Property_set_expr2Context) => Result;
-    visitAssignment_expr2?: (ctx: Assignment_expr2Context) => Result;
     visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
     visitComponent_modifier_expr?: (ctx: Component_modifier_exprContext) => Result;
     visitData_expr_with_assignment?: (ctx: Data_expr_with_assignmentContext) => Result;
+    visitAssignment_expr?: (ctx: Assignment_exprContext) => Result;
     visitAdd_component_expr?: (ctx: Add_component_exprContext) => Result;
     visitComponent_select_expr?: (ctx: Component_select_exprContext) => Result;
-    visitPin_select_expr2?: (ctx: Pin_select_expr2Context) => Result;
     visitAt_component_expr?: (ctx: At_component_exprContext) => Result;
     visitTo_component_expr?: (ctx: To_component_exprContext) => Result;
-    visitAt_to_multiple_expr?: (ctx: At_to_multiple_exprContext) => Result;
-    visitAt_to_multiple_line_expr?: (ctx: At_to_multiple_line_exprContext) => Result;
-    visitAt_to_multiple_line_expr_to_pin?: (ctx: At_to_multiple_line_expr_to_pinContext) => Result;
+    visitAt_block_header?: (ctx: At_block_headerContext) => Result;
     visitAt_block?: (ctx: At_blockContext) => Result;
     visitAt_block_expressions?: (ctx: At_block_expressionsContext) => Result;
-    visitAt_block_header?: (ctx: At_block_headerContext) => Result;
     visitAt_block_pin_expr?: (ctx: At_block_pin_exprContext) => Result;
-    visitAt_block_pin_expression_simple?: (ctx: At_block_pin_expression_simpleContext) => Result;
-    visitAt_block_pin_expression_complex?: (ctx: At_block_pin_expression_complexContext) => Result;
-    visitAssignment_expr?: (ctx: Assignment_exprContext) => Result;
-    visitOperator_assignment_expr?: (ctx: Operator_assignment_exprContext) => Result;
     visitKeyword_assignment_expr?: (ctx: Keyword_assignment_exprContext) => Result;
     visitParameters?: (ctx: ParametersContext) => Result;
-    visitProperty_set_expr?: (ctx: Property_set_exprContext) => Result;
     visitDouble_dot_property_set_expr?: (ctx: Double_dot_property_set_exprContext) => Result;
+    visitValueExpr?: (ctx: ValueExprContext) => Result;
     visitArrayExpr?: (ctx: ArrayExprContext) => Result;
-    visitArrayIndexExpr?: (ctx: ArrayIndexExprContext) => Result;
-    visitFunctionCallExpr?: (ctx: FunctionCallExprContext) => Result;
     visitAdditionExpr?: (ctx: AdditionExprContext) => Result;
     visitMultiplyExpr?: (ctx: MultiplyExprContext) => Result;
     visitLogicalOperatorExpr?: (ctx: LogicalOperatorExprContext) => Result;
-    visitDataExpr?: (ctx: DataExprContext) => Result;
+    visitCreateExpr?: (ctx: CreateExprContext) => Result;
     visitUnaryOperatorExpr?: (ctx: UnaryOperatorExprContext) => Result;
-    visitValueAtomExpr?: (ctx: ValueAtomExprContext) => Result;
+    visitCallableExpr?: (ctx: CallableExprContext) => Result;
     visitBinaryOperatorExpr?: (ctx: BinaryOperatorExprContext) => Result;
     visitRoundedBracketsExpr?: (ctx: RoundedBracketsExprContext) => Result;
-    visitBinary_operator?: (ctx: Binary_operatorContext) => Result;
-    visitUnary_operator?: (ctx: Unary_operatorContext) => Result;
     visitValue_expr?: (ctx: Value_exprContext) => Result;
     visitFunction_def_expr?: (ctx: Function_def_exprContext) => Result;
     visitFunction_expr?: (ctx: Function_exprContext) => Result;
     visitFunction_args_expr?: (ctx: Function_args_exprContext) => Result;
-    visitAtom_expr?: (ctx: Atom_exprContext) => Result;
-    visitTrailer_expr?: (ctx: Trailer_exprContext) => Result;
-    visitTrailer_expr2?: (ctx: Trailer_expr2Context) => Result;
-    visitFunction_call_expr?: (ctx: Function_call_exprContext) => Result;
-    visitNet_namespace_expr?: (ctx: Net_namespace_exprContext) => Result;
     visitFunction_return_expr?: (ctx: Function_return_exprContext) => Result;
+    visitNet_namespace_expr?: (ctx: Net_namespace_exprContext) => Result;
+    visitCallable_expr?: (ctx: Callable_exprContext) => Result;
+    visitTrailer?: (ctx: TrailerContext) => Result;
     visitProperty_block_expr?: (ctx: Property_block_exprContext) => Result;
-    visitCreate_component_expr?: (ctx: Create_component_exprContext) => Result;
+    visitProperties_block?: (ctx: Properties_blockContext) => Result;
     visitGraphic_expressions_block?: (ctx: Graphic_expressions_blockContext) => Result;
+    visitCreate_expr?: (ctx: Create_exprContext) => Result;
+    visitCreate_component_expr?: (ctx: Create_component_exprContext) => Result;
     visitCreate_graphic_expr?: (ctx: Create_graphic_exprContext) => Result;
     visitCreate_module_expr?: (ctx: Create_module_exprContext) => Result;
-    visitNested_properties_inner?: (ctx: Nested_properties_innerContext) => Result;
-    visitGraphicCommandExpr?: (ctx: GraphicCommandExprContext) => Result;
     visitGraphicForExpr?: (ctx: GraphicForExprContext) => Result;
+    visitGraphicCommandExpr?: (ctx: GraphicCommandExprContext) => Result;
     visitProperty_expr?: (ctx: Property_exprContext) => Result;
     visitProperty_key_expr?: (ctx: Property_key_exprContext) => Result;
     visitNested_properties?: (ctx: Nested_propertiesContext) => Result;
     visitSingle_line_property?: (ctx: Single_line_propertyContext) => Result;
-    visitWire_expr_direction_value?: (ctx: Wire_expr_direction_valueContext) => Result;
-    visitWire_expr_direction_only?: (ctx: Wire_expr_direction_onlyContext) => Result;
     visitWire_expr?: (ctx: Wire_exprContext) => Result;
-    visitArray_expr?: (ctx: Array_exprContext) => Result;
     visitPoint_expr?: (ctx: Point_exprContext) => Result;
     visitImport_simple?: (ctx: Import_simpleContext) => Result;
-    visitImport_all_simple?: (ctx: Import_all_simpleContext) => Result;
-    visitImport_specific?: (ctx: Import_specificContext) => Result;
-    visitImport_annotation_expr?: (ctx: Import_annotation_exprContext) => Result;
+    visitImport_specific_or_all?: (ctx: Import_specific_or_allContext) => Result;
     visitFrame_expr?: (ctx: Frame_exprContext) => Result;
     visitIf_expr?: (ctx: If_exprContext) => Result;
     visitIf_inner_expr?: (ctx: If_inner_exprContext) => Result;
@@ -177,7 +136,6 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitPart_match_block?: (ctx: Part_match_blockContext) => Result;
     visitPart_sub_expr?: (ctx: Part_sub_exprContext) => Result;
     visitPart_condition_expr?: (ctx: Part_condition_exprContext) => Result;
-    visitPart_condition_key_only_expr?: (ctx: Part_condition_key_only_exprContext) => Result;
     visitPart_value_expr?: (ctx: Part_value_exprContext) => Result;
     visitAnnotation_comment_expr?: (ctx: Annotation_comment_exprContext) => Result;
 }

package/dist/types/cache/deserializer.d.ts

@@ -0,0 +1,5 @@
+import { ExecutionContext } from '../execute.js';
+import { ImportedLibrary, ImportFunctionHandling } from '../objects/types.js';
+import { ImportFileResult } from '../BaseVisitor.js';
+import { LibraryCacheIR } from './types.js';
+export declare function deserializeLibraryScope(ir: LibraryCacheIR, name: string, libraryNamespace: string, filePathUsed: string, importHandling: ImportFunctionHandling, specificImports: string[], importContext: ExecutionContext, parseAndVisit: (miniScript: string, lineOffset: number) => ImportFileResult, enterContext: () => ExecutionContext, exitContext: () => void, libraryFileHash: string): ImportedLibrary;

package/dist/types/cache/hash.d.ts

@@ -0,0 +1 @@
+export declare function computeContentHash(fileContent: string): string;

package/dist/types/cache/serializer.d.ts

@@ -0,0 +1,3 @@
+import { ImportedLibrary } from '../objects/types.js';
+import { LibraryCacheIR } from './types.js';
+export declare function serializeLibraryScope(importedLib: ImportedLibrary, contentHash: string): LibraryCacheIR;

package/dist/types/cache/storage.d.ts

@@ -0,0 +1,4 @@
+import { LibraryCacheIR } from './types.js';
+export declare function getCachePath(libFilePath: string): string;
+export declare function readCache(libFilePath: string, hash: string): LibraryCacheIR | null;
+export declare function writeCache(libFilePath: string, hash: string, ir: LibraryCacheIR): void;

package/dist/types/cache/types.d.ts

@@ -0,0 +1,20 @@
+export declare const CACHE_SCHEMA_VERSION = 3;
+export type SerializedExpression = [
+    line: number,
+    column: number,
+    sourceText: string
+];
+export interface SerializedFunctionDef {
+    name: string;
+    namespace: string;
+    uniqueId: string;
+    sourceText: SerializedExpression;
+}
+export interface LibraryCacheIR {
+    schemaVersion: number;
+    contentHash: string;
+    libraryFilePath: string;
+    imports: SerializedExpression[];
+    functions: SerializedFunctionDef[];
+    topLevel: SerializedExpression[];
+}

package/dist/types/{environment.d.ts → environment/environment.d.ts}

@@ -1,7 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { Dom } from "@svgdotjs/svg.js";
 import fs from 'fs';
-import { SVGWindow } from "./helpers.js";
+import { SVGWindow } from "../helpers.js";
 export declare class NodeScriptEnvironment {
     existsSync(pathLike: string): boolean;
     mkdirSync(pathLike: string): void;
@@ -25,7 +25,7 @@ export declare class NodeScriptEnvironment {
     getToolsPath(): string;
     getFontsPath(): string;
     getDefaultLibsPath(): string;
-    private prepareSVGEnvironmentInternal;
+    protected prepareSVGEnvironmentInternal(fontsPath: string | null): Promise<void>;
     createSVGWindow(): SVGWindow;
     textMeasurementCanvas: Dom | undefined;
     getCanvasWindow(): Dom;
@@ -36,7 +36,7 @@ export declare class NodeScriptEnvironment {
     getDirPath(filePath: string): string;
     setCurrentFile(filePath: string): string;
     getCurrentFile(): string;
-    getRelativeToCurrentFolder(filePath: string): string;
+    getAbsPathRelativeToCurrentFolder(filePath: string): string;
     exists(path: fs.PathLike): Promise<boolean>;
     hashStringSHA256(value: string): string;
     dirname(filePath: string): string;
@@ -45,4 +45,5 @@ export declare class NodeScriptEnvironment {
     join(...paths: string[]): string;
     relative(from: string, to: string): string;
     createWriteStream(filePath: string): fs.WriteStream;
+    getCurrentDirectory(): string;
 }

package/dist/types/environment/esm-environment.d.ts

@@ -0,0 +1,4 @@
+import { NodeScriptEnvironment } from './environment';
+export declare class ESMNodeScriptEnvironment extends NodeScriptEnvironment {
+    protected prepareSVGEnvironmentInternal(fontsPath: string | null): Promise<void>;
+}

package/dist/types/environment/helpers.d.ts

@@ -0,0 +1,2 @@
+import { NodeScriptEnvironment } from "./environment";
+export declare function getNewEnvironment(): NodeScriptEnvironment;

package/dist/types/execute.d.ts

@@ -10,7 +10,7 @@ import { Wire } from './objects/Wire.js';
 import { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
 import { ParserRuleContext } from 'antlr4ng';
-import { SymbolDrawingCommands } from './draw_symbols.js';
+import { SymbolDrawingCommands } from './render/draw_symbols.js';
 export declare class ExecutionContext {
     name: string;
     namespace: string;
@@ -82,7 +82,8 @@ export declare class ExecutionContext {
     resetBreakContextFunctionCalls(): void;
     popBreakContext(): ParserRuleContext;
     getBreakContext(): ParserRuleContext;
-    createFunction(namespace: string, functionName: string, __runFunc: CFunction, source?: ParserRuleContext, uniqueId?: string): void;
+    createFunction(namespace: string, functionName: string, __runFunc: CFunction, source?: ParserRuleContext, uniqueId?: string): CFunctionEntry;
+    createFunctionLazyLoaded(namespace: string, functionName: string, uniqueId: string): CFunctionEntry;
     hasFunction(functionName: string): boolean;
     getFunction(functionName: string): CFunctionEntry;
     resolveVariable(executionStack: ExecutionContext[], idName: string, trailers?: string[]): AnyReference;

package/dist/types/globals.d.ts

@@ -117,3 +117,4 @@ export declare const RenderFlags: {
 export declare const SymbolValidatorContext = "_sym";
 export declare const TrailerArrayIndex = "index";
 export declare const DefaultComponentUnit = "__default";
+export declare const PinTypesList: string[];

package/dist/types/helpers.d.ts

@@ -1,16 +1,12 @@
 import { BaseError } from "./utils.js";
-import { ParserVisitor } from "./visitor.js";
 import { ParserRuleContext } from "antlr4ng";
-import { SymbolValidatorVisitor } from "./validate/SymbolValidatorVisitor.js";
-import { CommonTokenStream, DefaultErrorStrategy, Parser } from "antlr4ng";
+import { ATNSimulator, BaseErrorListener, CommonTokenStream, DefaultErrorStrategy, Parser, RecognitionException, Recognizer, Token } from "antlr4ng";
 import { CircuitScriptParser, ScriptContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
-import { IParsedToken, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
 import { LengthUnit } from "./globals.js";
 export type SVGWindow = any;
 import { NumericValue } from "./objects/ParamDefinition.js";
-import { NodeScriptEnvironment } from "./environment.js";
-import { ClassComponent } from "./objects/ClassComponent.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
 import { ImportedLibrary } from "./objects/types.js";
 export declare enum JSModuleType {
     CommonJs = "cjs",
@@ -27,6 +23,11 @@ export type ScriptOptions = {
     bomOutputPath?: string;
     updateSource?: boolean;
     saveAnnotatedCopy?: string | boolean;
+    lexerDiagnostics?: boolean;
+    lexerVerbose?: boolean;
+    lexerTokens?: number | boolean;
+    lexerMapping?: string | boolean;
+    lexerSummary?: boolean;
 };
 export declare function prepareFile(textData: string): {
     parser: CircuitScriptParser;
@@ -34,28 +35,36 @@ export declare function prepareFile(textData: string): {
     lexerTimeTaken: number;
     tokens: CommonTokenStream;
 };
-export declare function getSemanticTokens(scriptData: string, options: ScriptOptions): Promise<{
-    visitor: SemanticTokensVisitor;
-    parsedTokens: IParsedToken[];
-}>;
+export declare class TokenErrorListener extends BaseErrorListener {
+    syntaxError<S extends Token, T extends ATNSimulator>(recognizer: Recognizer<T>, offendingSymbol: S | null, line: number, column: number, msg: string, e: RecognitionException | null): void;
+}
 export declare class ParseErrorStrategy extends DefaultErrorStrategy {
     reportUnwantedToken(recognizer: Parser): void;
 }
-export declare function validateScript(filePath: string, scriptData: string, options: ScriptOptions): Promise<SymbolValidatorVisitor>;
-type RenderScriptReturn = {
+export type RenderScriptReturn = {
     svgOutput: string | null;
     errors: BaseError[];
 };
-export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<RenderScriptReturn>;
-export declare function renderScriptCustom(scriptData: string, outputPath: string | null, options: ScriptOptions, parseHandlers: ParseOutputHandler[], postAnnotationCallbacks: ((options: ScriptOptions, scriptData: string, tree: ScriptContext, tokens: CommonTokenStream, componentLinks: Map<ParserRuleContext, ClassComponent>, importedLibraries: ImportedLibrary[], environment: NodeScriptEnvironment) => void)[]): Promise<RenderScriptReturn>;
-export declare abstract class ParseOutputHandler {
-    beforeRender: boolean;
-    afterRender: boolean;
-    abstract parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null, extra: any | null): boolean;
-}
-export declare class KiCadNetListOutputHandler extends ParseOutputHandler {
-    beforeRender: boolean;
-    parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null): boolean;
+export type ExternalLibAnnotationFile = {
+    name: string;
+    path: string;
+    items: Record<string, string>;
+};
+export type AnnotatedFile = {
+    isMainFile?: boolean;
+    tokens: CommonTokenStream;
+    tree: ScriptContext;
+    filePath: string;
+    scriptData: string;
+    libraryName?: string;
+    outputType: RefdesOutputType;
+    library?: ImportedLibrary;
+    referencedTokens?: [tokens: CommonTokenStream, tree: ParserRuleContext][];
+};
+export declare enum RefdesOutputType {
+    None = "none",
+    WithSource = "with-source",
+    CreateExternalFile = "create-external-file"
 }
 export declare function detectJSModuleType(): JSModuleType;
 export declare class UnitDimension {
@@ -68,17 +77,3 @@ export declare class UnitDimension {
     static px(value: number): UnitDimension;
 }
 export declare function milsToMM(value: NumericValue | number): NumericValue;
-export declare function pxToMM(value: number): number;
-export declare const PaperGridReferences: {
-    [key: string]: [rows: number, columns: number];
-};
-export declare function isSupportedPaperSize(type: string): boolean;
-export declare function getPaperSize(type: string, margin?: number): {
-    width: number;
-    height: number;
-    widthMM: number;
-    heightMM: number;
-    originalWidthMM: number;
-    originalHeightMM: number;
-};
-export {};

package/dist/types/importResolver.d.ts

@@ -0,0 +1,4 @@
+import { NodeScriptEnvironment } from './environment/environment.js';
+export declare function extractImportNames(fileData: string): string[];
+export declare function resolveAllImportFilepaths(rootFilePath: string | null, scriptData: string | null, environment: NodeScriptEnvironment): Promise<string[]>;
+export declare function loadImportsIntoMemoryStore(filepaths: string[], environment: NodeScriptEnvironment): Promise<Map<string, string>>;

package/dist/types/index.d.ts

@@ -1,14 +1,17 @@
-export * from './draw_symbols.js';
+export * from './render/draw_symbols.js';
 export * from './execute.js';
-export * from './export.js';
-export * from './geometry.js';
+export * from './render/export.js';
+export * from './render/geometry.js';
+export * from './pipeline.js';
 export * from './globals.js';
 export * from './helpers.js';
-export * from './layout.js';
+export * from './render/layout.js';
+export * from './render/render.js';
+export * from './render/KiCadNetListOutputHandler.js';
 export * from './lexer.js';
+export * from './LexerDiagnosticListener.js';
 export * from './logger.js';
 export * from './parser.js';
-export * from './render.js';
 export * from './utils.js';
 export * from './visitor.js';
 export * from './sizing.js';
@@ -17,5 +20,7 @@ export * from './builtinMethods.js';
 export * from './validate/SymbolTable.js';
 export * from './validate/SymbolValidatorResolveVisitor.js';
 export * from './validate/SymbolValidatorVisitor.js';
-export * from './environment.js';
-export * from './RefdesAnnotationVisitor.js';
+export * from './validate/validateScript.js';
+export * from './environment/environment.js';
+export * from './annotate/RefdesAnnotationVisitor.js';
+export * from './semantic-tokens/getSemanticTokens.js';

package/dist/types/lexer.d.ts

@@ -1,19 +1,23 @@
 import { CharStream, Token } from "antlr4ng";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
+import { LexerDiagnosticCollector } from "./LexerDiagnosticListener.js";
 export declare class MainLexer extends CircuitScriptLexer {
-    tokens: any[];
-    indents: any[];
+    tokens: Token[];
+    private tokensHead;
+    indents: number[];
     opened: number;
-    constructor(input: CharStream);
+    diagnosticCollector: LexerDiagnosticCollector;
+    lineOffset: number;
+    constructor(input: CharStream, enableDiagnostics?: boolean);
     reset(): void;
     emitToken(token: Token): void;
     nextToken(): Token;
     createDedent(): Token;
     getCharIndex(): number;
     commonToken(type: number, text: string, start?: number, stop?: number): Token;
-    getIndentationCount(whitespace: string): number;
-    atStartOfInput(): boolean;
+    private getIndentationCount;
     openBrace(): void;
     closeBrace(): void;
     onNewLine(): void;
+    setLineOffset(offset: number): void;
 }

package/dist/types/objects/ClassComponent.d.ts

@@ -1,6 +1,6 @@
 import { ParserRuleContext } from 'antlr4ng';
 import { Expressions_blockContext } from 'src/antlr/CircuitScriptParser.js';
-import { SymbolDrawingCommands } from '../draw_symbols.js';
+import { SymbolDrawingCommands } from '../render/draw_symbols.js';
 import { Net } from './Net.js';
 import { PinDefinition, PinId } from './PinDefinition.js';
 import { WireSegment } from './Wire.js';

package/dist/types/objects/ExecutionScope.d.ts

@@ -1,6 +1,6 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, CFunctionEntry, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ImportedLibrary, ParseSymbolType, ValueType } from './types.js';
+import { CFunction, CFunctionEntry, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ImportedLibrary, ValueType } from './types.js';
 import { BlockTypes, LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
@@ -16,9 +16,6 @@ export declare class ExecutionScope {
     functions: Map<string, CFunctionEntry>;
     functionCounter: Map<CFunction, number>;
     variables: Map<string, ValueType | ClassComponent>;
-    symbols: Map<string, {
-        type: ParseSymbolType;
-    }>;
     libraries: Map<string, ImportedLibrary>;
     blockStack: Map<number, BlockStackEntry>;
     contextStack: ParserRuleContext[];

package/dist/types/objects/types.d.ts

@@ -6,7 +6,9 @@ import { NumericValue, PercentageValue } from './ParamDefinition.js';
 import { ReferenceTypes } from '../globals.js';
 import { PinDefinition, PinId } from './PinDefinition.js';
 import { ScriptContext } from 'src/antlr/CircuitScriptParser.js';
-import { SymbolDrawingCommands } from 'src/draw_symbols.js';
+import { SymbolDrawingCommands } from 'src/render/draw_symbols.js';
+import { RefdesModification } from 'src/annotate/utils.js';
+import { SerializedExpression } from 'src/cache/types.js';
 export type CFunction = (args: CallableParameter[], options?: CFunctionOptions) => CFunctionResult;
 export declare class CFunctionEntry {
     name: string;
@@ -15,8 +17,13 @@ export declare class CFunctionEntry {
     execute: CFunction;
     uniqueId?: string;
     source?: ParserRuleContext;
+    lazyLoaded: boolean;
+    lazyLoader: (() => void) | null;
+    tokens: CommonTokenStream;
+    tree: ScriptContext;
     constructor(namespace: string, name: string, execute: CFunction, source?: ParserRuleContext, uniqueId?: string);
     toString(): string;
+    getFunctionPath(): string;
 }
 export type CFunctionOptions = {
     netNamespace?: string;
@@ -123,7 +130,14 @@ export declare class ImportedLibrary {
     enableRefdesAnnotationFile: boolean;
     tree: ScriptContext;
     tokens: CommonTokenStream;
-    constructor(libraryName: string, libraryNamespace: string, libraryFilePath: string, tree: ScriptContext, tokens: CommonTokenStream, context: ExecutionContext, flag: ImportFunctionHandling, specifiedImports: string[]);
+    referencedTokens: [tokens: CommonTokenStream, tree: ParserRuleContext][];
+    fileHash: string;
+    writeToCache: boolean;
+    refdesAnnotations: Map<ParserRuleContext, RefdesModification>;
+    parseError: boolean;
+    importStatement: SerializedExpression;
+    constructor(libraryName: string, libraryNamespace: string, libraryFilePath: string, tree: ScriptContext, tokens: CommonTokenStream, context: ExecutionContext, flag: ImportFunctionHandling, specifiedImports: string[], fileHash: string, importStatement: SerializedExpression);
+    addRefdesModifications(mods: Map<ParserRuleContext, RefdesModification>): void;
 }
 export declare enum ImportFunctionHandling {
     AllWithNamespace = "all-with-namespace",

package/dist/types/parser.d.ts

@@ -1,16 +1,23 @@
 import { CircuitScriptParser, ScriptContext } from './antlr/CircuitScriptParser.js';
+import { MainLexer } from './lexer.js';
 import { ANTLRErrorListener, ATNConfigSet, ATNSimulator, BitSet, CommonTokenStream, DFA, Parser, RecognitionException, Recognizer, Token } from 'antlr4ng';
 import { BaseVisitor, OnErrorHandler } from './BaseVisitor.js';
-export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string): Promise<{
+export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string, options?: {
+    enableLexerDiagnostics?: boolean;
+    enableLexerVerbose?: boolean;
+    enableLexerTokenStream?: boolean;
+    lineOffset: number;
+}): {
     tree: ScriptContext;
     parser: CircuitScriptParser;
     tokens: CommonTokenStream;
+    lexer: MainLexer;
     hasError: boolean;
     hasParseError: boolean;
     parserTimeTaken: number;
     lexerTimeTaken: number;
     throwError: any;
-}>;
+};
 export declare class CircuitscriptParserErrorListener implements ANTLRErrorListener {
     syntaxErrorCounter: number;
     onErrorHandler: OnErrorHandler | null;

package/dist/types/pipeline.d.ts

@@ -0,0 +1,9 @@
+import { CommonTokenStream, ParserRuleContext } from "antlr4ng";
+import { ScriptContext } from "./antlr/CircuitScriptParser.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
+import { ScriptOptions, RenderScriptReturn } from "./helpers.js";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { ImportedLibrary } from "./objects/types.js";
+import { ParseOutputHandler } from "./render/KiCadNetListOutputHandler.js";
+export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<RenderScriptReturn>;
+export declare function renderScriptCustom(scriptData: string, outputPath: string | null, options: ScriptOptions, parseHandlers: ParseOutputHandler[], postAnnotationCallbacks: ((options: ScriptOptions, scriptData: string, tree: ScriptContext, tokens: CommonTokenStream, componentLinks: Map<ParserRuleContext, ClassComponent>, importedLibraries: ImportedLibrary[], environment: NodeScriptEnvironment) => void)[]): Promise<RenderScriptReturn>;

package/dist/types/render/KiCadNetListOutputHandler.d.ts

@@ -0,0 +1,10 @@
+import { ParserVisitor } from "../visitor.js";
+export declare abstract class ParseOutputHandler {
+    beforeRender: boolean;
+    afterRender: boolean;
+    abstract parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null, extra: any | null): boolean;
+}
+export declare class KiCadNetListOutputHandler extends ParseOutputHandler {
+    beforeRender: boolean;
+    parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null): boolean;
+}

package/dist/types/render/PaperSizes.d.ts

@@ -0,0 +1,12 @@
+export declare const PaperGridReferences: {
+    [key: string]: [rows: number, columns: number];
+};
+export declare function isSupportedPaperSize(type: string): boolean;
+export declare function getPaperSize(type: string, margin?: number): {
+    width: number;
+    height: number;
+    widthMM: number;
+    heightMM: number;
+    originalWidthMM: number;
+    originalHeightMM: number;
+};

package/dist/types/{draw_symbols.d.ts → render/draw_symbols.d.ts}

@@ -1,10 +1,10 @@
 import { G } from "@svgdotjs/svg.js";
 import { Feature, GeometryProp, HorizontalAlign, LabelStyle, Textbox, VerticalAlign } from "./geometry.js";
-import { Logger } from "./logger.js";
-import { PinTypes } from "./objects/PinTypes.js";
+import { Logger } from "../logger.js";
+import { PinTypes } from "../objects/PinTypes.js";
 import { ParserRuleContext } from "antlr4ng";
-import { NumericValue } from "./objects/ParamDefinition.js";
-import { PinId } from "./objects/PinDefinition.js";
+import { NumericValue } from "../objects/ParamDefinition.js";
+import { PinId } from "../objects/PinDefinition.js";
 export declare abstract class SymbolGraphic {
     drawPortsName: boolean;
     displayBounds: boolean;