circuitscript 0.1.33 → 0.3.0

package/dist/cjs/objects/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportFunctionHandling = exports.ImportedModule = exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
+exports.ImportFunctionHandling = exports.ImportedLibrary = exports.NetTypes = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
 const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
 class CFunctionEntry {
@@ -111,29 +111,18 @@ var Direction;
     Direction["Down"] = "down";
     Direction["Up"] = "up";
 })(Direction || (exports.Direction = Direction = {}));
-var TypeProps;
-(function (TypeProps) {
-    TypeProps["Net"] = "net";
-    TypeProps["Port"] = "port";
-    TypeProps["Graphic"] = "graphic";
-    TypeProps["Module"] = "module";
-    TypeProps["Resistor"] = "res";
-    TypeProps["Capacitor"] = "cap";
-    TypeProps["Inductor"] = "ind";
-    TypeProps["Diode"] = "diode";
-})(TypeProps || (exports.TypeProps = TypeProps = {}));
 var NetTypes;
 (function (NetTypes) {
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
-class ImportedModule {
-    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
+class ImportedLibrary {
+    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports) {
         this.enableRefdesAnnotation = false;
         this.enableRefdesAnnotationFile = false;
-        this.moduleName = moduleName;
-        this.moduleNamespace = moduleNamespace;
-        this.moduleFilePath = moduleFilePath;
+        this.libraryName = libraryName;
+        this.libraryNamespace = libraryNamespace;
+        this.libraryFilePath = libraryFilePath;
         this.tree = tree;
         this.tokens = tokens;
         this.context = context;
@@ -141,7 +130,7 @@ class ImportedModule {
         this.specifiedImports = specifiedImports;
     }
 }
-exports.ImportedModule = ImportedModule;
+exports.ImportedLibrary = ImportedLibrary;
 var ImportFunctionHandling;
 (function (ImportFunctionHandling) {
     ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -167,24 +167,24 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
             });
             specifiedImports.push(...tmpImports);
         }
-        const id = ctx._moduleName.text;
-        const { pathExists, importedModule } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
+        const id = ctx._libraryName.text;
+        const { pathExists, importedLibrary } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
         if (!pathExists) {
-            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._moduleName);
+            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._libraryName);
         }
         else {
-            this.applyModuleImports(importedModule);
+            this.applyLibraryImports(importedLibrary);
         }
     }
-    applyModuleImports(module) {
-        const { importHandlingFlag: importHandling, specifiedImports } = module;
+    applyLibraryImports(library) {
+        const { importHandlingFlag: importHandling, specifiedImports } = library;
         const addedSymbols = [];
         const executor = this.getExecutor();
         const symbolTable = this.symbolTable.getSymbols();
         symbolTable.forEach((value, key) => {
             if (value.type === types_js_1.ParseSymbolType.Function) {
                 const definedSymbol = value;
-                if (definedSymbol.fileName === module.moduleFilePath) {
+                if (definedSymbol.fileName === library.libraryFilePath) {
                     const addSymbolToNamespace = importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
                         || (importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
                             && specifiedImports.indexOf(definedSymbol.id) !== -1);

package/dist/cjs/visitor.js

@@ -351,7 +351,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 return new PinDefinition_js_1.PinDefinition(index + 1, PinDefinition_js_1.PinIdType.Int, portName, PinTypes_js_1.PinTypes.Any);
             });
             const arrange = this.getArrangePropFromModulePorts(modulePorts, nameToPinId);
-            const unitProperties = this.extractComponentUnitProperties(properties, types_js_1.TypeProps.Module);
+            const unitProperties = this.extractComponentUnitProperties(properties, globals_js_1.ComponentTypes.module);
             const firstUnitDef = unitProperties[0][1];
             firstUnitDef.pins = tmpPorts;
             firstUnitDef.arrange = arrange;
@@ -362,7 +362,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             };
             const moduleInstanceName = this.getExecutor().getUniqueInstanceName();
             const moduleComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props, true);
-            moduleComponent.typeProp = types_js_1.TypeProps.Module;
+            moduleComponent.typeProp = globals_js_1.ComponentTypes.module;
             const ctxPropertyBlock = ctx.property_block_expr();
             if (ctxPropertyBlock) {
                 const [firstBlock] = ctxPropertyBlock;
@@ -1148,7 +1148,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         const display = properties.get('display') ?? null;
         const suffix = properties.get('suffix') ?? null;
         let pins = [];
-        if (display !== null && arrange === null && typeProp !== types_js_1.TypeProps.Graphic) {
+        if (display !== null && arrange === null && typeProp !== globals_js_1.ComponentTypes.graphic) {
             const drawCommands = display.getCommands();
             drawCommands.forEach(command => {
                 const [commandValue,] = command;
@@ -1385,7 +1385,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             currentComponent.forceSaveRefdesAnnotation = forceSave;
         }
     }
-    async checkModuleHasRefdesFile(filePath) {
+    async checkLibraryHasRefdesFile(filePath) {
         const dir = this.environment.dirname(filePath);
         const ext = this.environment.extname(filePath);
         const basename = this.environment.basename(filePath, ext);
@@ -1655,8 +1655,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         const fullNetNames = Array.from(uniqueNets).map(item => item.toString());
         nets.forEach(([component, pin, net]) => {
             if (net.priority === 0 && seenNets.indexOf(net) === -1
-                && component.typeProp !== types_js_1.TypeProps.Module
-                && component.typeProp !== types_js_1.TypeProps.Net) {
+                && component.typeProp !== globals_js_1.ComponentTypes.module
+                && component.typeProp !== globals_js_1.ComponentTypes.net) {
                 net.name = net.baseName =
                     `NET-(${component.assignedRefDes}-${pin.toString()})`;
                 if (fullNetNames.indexOf(net.toString()) !== -1) {

package/dist/esm/BaseVisitor.js

@@ -6,7 +6,7 @@ import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumberOperator, NumericValue, PercentageValue } from "./objects/ParamDefinition.js";
 import { PinTypes } from "./objects/PinTypes.js";
-import { Direction, AnyReference, UndeclaredReference, ImportedModule, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
+import { Direction, AnyReference, UndeclaredReference, ImportedLibrary, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
 import { BaseNamespace, ComponentTypes, DoubleDelimiter1, GlobalDocumentName, ReferenceTypes, TrailerArrayIndex } from './globals.js';
 import { isReference, unwrapValue as unwrapValue } from "./utils.js";
 import { linkBuiltInMethods } from './builtinMethods.js';
@@ -145,17 +145,17 @@ export class BaseVisitor extends CircuitScriptVisitor {
             });
             specificImports.push(...tmpSpecificImports);
         }
-        const id = ctx._moduleName.text;
+        const id = ctx._libraryName.text;
         const importedFile = await this.handleImportFile(id, handling, true, ctx, specificImports);
         const ctxImportAnnotation = ctx.import_annotation_expr();
         if (ctxImportAnnotation) {
             const textValue = ctxImportAnnotation.getText().replace('#=', '');
-            const { importedModule } = importedFile;
+            const { importedLibrary } = importedFile;
             if (textValue === 'annotate') {
-                importedModule.enableRefdesAnnotation = true;
+                importedLibrary.enableRefdesAnnotation = true;
             }
             else if (textValue === 'annotate-external') {
-                importedModule.enableRefdesAnnotationFile = true;
+                importedLibrary.enableRefdesAnnotationFile = true;
             }
         }
     }
@@ -417,23 +417,23 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     }
                     const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
                     try {
-                        const isModuleFunction = currentReference.rootValue
-                            && currentReference.rootValue instanceof ImportedModule;
-                        if (isModuleFunction) {
-                            this.log('create new module context');
-                            const importedModule = currentReference.rootValue;
-                            const importedModuleContext = importedModule.context;
-                            this.enterFile(importedModule.moduleFilePath);
-                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedModuleContext.name, ctx, {
+                        const isLibraryFunction = currentReference.rootValue
+                            && currentReference.rootValue instanceof ImportedLibrary;
+                        if (isLibraryFunction) {
+                            this.log('create new library context');
+                            const importedLibrary = currentReference.rootValue;
+                            const { context: importedLibraryContext } = importedLibrary;
+                            this.enterFile(importedLibrary.libraryFilePath);
+                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
                                 netNamespace: executor.netNamespace,
-                                namespace: importedModule.moduleNamespace
+                                namespace: importedLibrary.libraryNamespace
                             }, [], [], false);
-                            this.log('copy module context scope');
-                            importedModuleContext.scope.copyTo(newExecutor.scope);
+                            this.log('copy library context scope');
+                            importedLibraryContext.scope.copyTo(newExecutor.scope);
                         }
                         const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
-                        if (isModuleFunction) {
-                            this.log('pop module context scope');
+                        if (isLibraryFunction) {
+                            this.log('pop library context scope');
                             this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
                             this.exitFile();
                         }
@@ -712,8 +712,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
             return item.id === name;
         });
         if (importAlready) {
-            const tmpImportedModule = importAlready.importedModule;
-            const alreadyImportedFlag = tmpImportedModule.importHandlingFlag;
+            const { importedLibrary: tmpImportedLibrary } = importAlready;
+            const alreadyImportedFlag = tmpImportedLibrary.importHandlingFlag;
             const isMergedNamespace = alreadyImportedFlag === ImportFunctionHandling.AllMergeIntoNamespace
                 || alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace;
             const invalidImportCondition1 = alreadyImportedFlag === ImportFunctionHandling.AllWithNamespace &&
@@ -727,11 +727,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 if (alreadyImportedFlag === ImportFunctionHandling.AllMergeIntoNamespace) {
                 }
                 else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.AllMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports = [];
-                    tmpImportedModule.importHandlingFlag = ImportFunctionHandling.AllMergeIntoNamespace;
+                    tmpImportedLibrary.specifiedImports = [];
+                    tmpImportedLibrary.importHandlingFlag = ImportFunctionHandling.AllMergeIntoNamespace;
                 }
                 else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports.push(...specificImports);
+                    tmpImportedLibrary.specifiedImports.push(...specificImports);
                 }
             }
             return importAlready;
@@ -752,7 +752,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
             this.log('failed to read file');
             pathExists = false;
         }
-        let importedModule;
+        let importedLibrary;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
@@ -773,26 +773,26 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 const executor = this.getExecutor();
                 const executionContextName = name;
                 const netNamespace = executor.netNamespace;
-                const moduleNamespace = `${BaseNamespace}${name}.`;
+                const libraryNamespace = `${BaseNamespace}${name}.`;
                 this.enterNewChildContext(executionStack, executor, executionContextName, {
                     netNamespace,
-                    namespace: moduleNamespace,
+                    namespace: libraryNamespace,
                 }, [], []);
                 const importResult = await this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
                 hasError = importResult.hasError;
                 hasParseError = importResult.hasParseError;
                 const importContext = executionStack.pop();
                 this.log(`import handling flag: ${importHandling}`);
-                importedModule = new ImportedModule(name, moduleNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
+                importedLibrary = new ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
                 if (specificImports.length > 0) {
                     this.log('specific import: ' + specificImports.join(', '));
                 }
                 const scope = this.getScope();
-                scope.modules.set(name, importedModule);
-                importedModule.context.scope.modules.forEach((module, key) => {
-                    scope.modules.set(key, module);
+                scope.libraries.set(name, importedLibrary);
+                importedLibrary.context.scope.libraries.forEach((lib, key) => {
+                    scope.libraries.set(key, lib);
                 });
-                await this.checkModuleHasRefdesFile(filePathUsed);
+                await this.checkLibraryHasRefdesFile(filePathUsed);
             }
         }
         catch (err) {
@@ -820,12 +820,12 @@ export class BaseVisitor extends CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
-            importedModule: importedModule
+            importedLibrary: importedLibrary
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
     }
-    async checkModuleHasRefdesFile(filePath) {
+    async checkLibraryHasRefdesFile(filePath) {
         return;
     }
     getRefdesFileAnnotation(filePath, startLine, startColumn, stopLine, stopColumn) {

package/dist/esm/BomGeneration.js

@@ -1,5 +1,4 @@
 import * as csv from '@fast-csv/format';
-import * as fs from 'fs';
 import { NumericValue } from "./objects/ParamDefinition.js";
 const TypeSortOrder = {
     "res": 1,
@@ -122,9 +121,9 @@ export function generateBomCSV(bomData) {
     });
     return rows;
 }
-export async function saveBomOutputCsv(bomCsvOutput, filePath) {
+export async function saveBomOutputCsv(environment, bomCsvOutput, filePath) {
     return new Promise(resolve => {
-        const outputStream = fs.createWriteStream(filePath);
+        const outputStream = environment.createWriteStream(filePath);
         const csvStream = csv.format();
         csvStream.pipe(outputStream).on("finish", () => {
             resolve();

package/dist/esm/ComponentMatchConditions.js

@@ -1,5 +1,5 @@
+import { ComponentTypes } from "./globals.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
-import { TypeProps } from "./objects/types.js";
 export function flattenConditionNodes(conditionNodes, level = 0) {
     const conditionBranches = [];
     conditionNodes.forEach(node => {
@@ -95,7 +95,7 @@ export function partMatchesConditions(instance, partConditions) {
 }
 export function applyPartConditions(instances, paramKeys, partConditions) {
     instances.forEach(item => {
-        if (item.typeProp !== TypeProps.Graphic) {
+        if (item.typeProp !== ComponentTypes.graphic) {
             const matchedResult = partMatchesConditions(item, partConditions);
             if (matchedResult !== undefined) {
                 paramKeys.forEach((paramKey, index) => {

package/dist/esm/SemanticTokenVisitor.js

@@ -208,7 +208,7 @@ export function prepareTokens(tokens, lexer, script) {
 const languageKeywords = [
     'break', 'branch', 'create', 'component',
     'graphic', 'wire', 'pin', 'add', 'at', 'to',
-    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'point', 'join', 'parallel', 'return', 'def', 'from', 'import',
     'true', 'false', 'nc', 'sheet', 'frame', 'if', 'else', 'for', 'in',
 ];
 const operatorKeywords = [

package/dist/esm/antlr/CircuitScriptParser.js

@@ -3572,7 +3572,7 @@ export class CircuitScriptParser extends antlr.Parser {
                         this.state = 686;
                         this.match(CircuitScriptParser.Import);
                         this.state = 687;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 689;
                         this.errorHandler.sync(this);
                         switch (this.interpreter.adaptivePredict(this.tokenStream, 76, this.context)) {
@@ -3592,7 +3592,7 @@ export class CircuitScriptParser extends antlr.Parser {
                         this.state = 691;
                         this.match(CircuitScriptParser.From);
                         this.state = 692;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 693;
                         this.match(CircuitScriptParser.Import);
                         this.state = 694;
@@ -3616,7 +3616,7 @@ export class CircuitScriptParser extends antlr.Parser {
                         this.state = 698;
                         this.match(CircuitScriptParser.From);
                         this.state = 699;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 700;
                         this.match(CircuitScriptParser.Import);
                         this.state = 701;
@@ -6760,7 +6760,7 @@ export class Import_exprContext extends antlr.ParserRuleContext {
     }
 }
 export class Import_specificContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     _ID;
     _funcNames = [];
     constructor(ctx) {
@@ -6794,7 +6794,7 @@ export class Import_specificContext extends Import_exprContext {
     }
 }
 export class Import_all_simpleContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     constructor(ctx) {
         super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
@@ -6824,7 +6824,7 @@ export class Import_all_simpleContext extends Import_exprContext {
     }
 }
 export class Import_simpleContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     constructor(ctx) {
         super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);

package/dist/esm/builtinMethods.js

@@ -1,6 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { CFunctionEntry, ImportedModule } from "./objects/types.js";
+import { CFunctionEntry, ImportedLibrary } from "./objects/types.js";
 import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 import { BaseNamespace } from "./globals.js";
 const builtInMethods = [
@@ -149,8 +149,8 @@ function toString(obj) {
     else if (obj instanceof CFunctionEntry) {
         return obj.toString();
     }
-    else if (obj instanceof ImportedModule) {
-        return `[module: ${obj.moduleName}]`;
+    else if (obj instanceof ImportedLibrary) {
+        return `[library: ${obj.libraryName}]`;
     }
     else {
         if (obj === undefined) {

package/dist/esm/environment.js

@@ -1,11 +1,16 @@
 import { registerWindow, SVG } from "@svgdotjs/svg.js";
-import { writeFileSync } from "fs";
 import fs from 'fs';
 import path from "path";
 import CryptoJs from "crypto-js";
 import { TOOL_VERSION } from "./globals.js";
 import { RuntimeExecutionError } from "./utils.js";
 export class NodeScriptEnvironment {
+    existsSync(pathLike) {
+        return fs.existsSync(pathLike);
+    }
+    mkdirSync(pathLike) {
+        return fs.mkdirSync(pathLike);
+    }
     static _instance = null;
     static setInstance(instance) {
         NodeScriptEnvironment._instance = instance;
@@ -117,7 +122,7 @@ export class NodeScriptEnvironment {
         return fs.promises.readFile(path, options);
     }
     writeFileSync(path, data) {
-        return writeFileSync(path, data);
+        return fs.writeFileSync(path, data);
     }
     getAbsolutePath(filePath) {
         return path.resolve(filePath);
@@ -162,4 +167,7 @@ export class NodeScriptEnvironment {
     relative(from, to) {
         return path.relative(from, to);
     }
+    createWriteStream(filePath) {
+        return fs.createWriteStream(filePath);
+    }
 }

package/dist/esm/execute.js

@@ -646,19 +646,18 @@ export class ExecutionContext {
                 });
             }
             else {
-                const modules = Array.from(context.scope.modules.values());
-                for (let j = 0; j < modules.length; j++) {
-                    const module = modules[j];
-                    if (module.importHandlingFlag === ImportFunctionHandling.AllMergeIntoNamespace ||
-                        (module.importHandlingFlag === ImportFunctionHandling.SpecificMergeIntoNamespace
-                            && module.specifiedImports.indexOf(idName) !== -1)) {
-                        const moduleContext = module.context;
-                        const functionPath = `${moduleContext.namespace}${idName}`;
-                        if (module.context.hasFunction(functionPath)) {
+                const libraries = Array.from(context.scope.libraries.values());
+                for (const library of libraries) {
+                    if (library.importHandlingFlag === ImportFunctionHandling.AllMergeIntoNamespace ||
+                        (library.importHandlingFlag === ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && library.specifiedImports.indexOf(idName) !== -1)) {
+                        const { context: libraryContext } = library;
+                        const functionPath = `${libraryContext.namespace}${idName}`;
+                        if (library.context.hasFunction(functionPath)) {
                             return new DeclaredReference({
                                 found: true,
-                                rootValue: module,
-                                value: module.context.getFunction(functionPath),
+                                rootValue: library,
+                                value: library.context.getFunction(functionPath),
                                 type: ReferenceTypes.function,
                                 name: idName,
                                 trailerIndex: 1,
@@ -667,24 +666,24 @@ export class ExecutionContext {
                         }
                     }
                 }
-                let isModule = false;
-                if (context.scope.modules.has(idName)) {
-                    const module = context.scope.modules.get(idName);
-                    if (module.importHandlingFlag === ImportFunctionHandling.AllWithNamespace) {
-                        isModule = true;
+                let isLibrary = false;
+                if (context.scope.libraries.has(idName)) {
+                    const library = context.scope.libraries.get(idName);
+                    if (library.importHandlingFlag === ImportFunctionHandling.AllWithNamespace) {
+                        isLibrary = true;
                     }
                 }
                 let isVariable = context.scope.variables.has(idName);
                 let isComponentInstance = context.scope.instances.has(idName);
-                if (isModule || isVariable || isComponentInstance) {
-                    const scopeList = isModule ? context.scope.modules :
+                if (isLibrary || isVariable || isComponentInstance) {
+                    const scopeList = isLibrary ? context.scope.libraries :
                         (isVariable ? context.scope.variables : context.scope.instances);
                     const useValue = scopeList.get(idName);
                     if (!isComponentInstance && (useValue instanceof ClassComponent)) {
                         isComponentInstance = true;
                         isVariable = false;
                     }
-                    const referenceType = isModule ? ReferenceTypes.module :
+                    const referenceType = isLibrary ? ReferenceTypes.library :
                         (isVariable ? ReferenceTypes.variable : ReferenceTypes.instance);
                     const tmpReference = this.resolveTrailers(referenceType, useValue, trailers);
                     return new DeclaredReference({
@@ -731,12 +730,12 @@ export class ExecutionContext {
                     }
                     break;
                 }
-                case ReferenceTypes.module: {
+                case ReferenceTypes.library: {
                     const funcName = trailers[0];
-                    const module = rootValue;
-                    const functionPath = `${module.moduleNamespace}${funcName}`;
-                    if (module.context.hasFunction(functionPath)) {
-                        const foundFunc = module.context.getFunction(functionPath);
+                    const library = rootValue;
+                    const functionPath = `${library.libraryNamespace}${funcName}`;
+                    if (library.context.hasFunction(functionPath)) {
+                        const foundFunc = library.context.getFunction(functionPath);
                         return new AnyReference({
                             found: true,
                             type: ReferenceTypes.function,
@@ -1017,6 +1016,11 @@ export class ExecutionContext {
                     ParamKeys.flipY,
                 ];
                 if (unitModifiers.indexOf(paramName) !== -1) {
+                    if (paramName === ParamKeys.flipX || paramName == ParamKeys.flipY) {
+                        if (typeof value === "boolean") {
+                            value = value ? numeric(1) : numeric(0);
+                        }
+                    }
                     component.getUnit().setParam(paramName, value);
                 }
             }

package/dist/esm/globals.js

@@ -87,6 +87,7 @@ export var ComponentTypes;
     ComponentTypes["graphic"] = "graphic";
     ComponentTypes["port"] = "port";
     ComponentTypes["module"] = "module";
+    ComponentTypes["resistor"] = "res";
 })(ComponentTypes || (ComponentTypes = {}));
 export var ReferenceTypes;
 (function (ReferenceTypes) {
@@ -95,7 +96,7 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
-    ReferenceTypes["module"] = "module";
+    ReferenceTypes["library"] = "library";
     ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (ReferenceTypes = {}));
 export var BlockTypes;

package/dist/esm/graph.js

@@ -6,7 +6,7 @@ import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire
 import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
 import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
 import { numeric } from "./objects/ParamDefinition.js";
-import { NetTypes, TypeProps } from "./objects/types.js";
+import { NetTypes } from "./objects/types.js";
 import Matrix, { solve } from "ml-matrix";
 import { getPinDefinition, PinId } from "./objects/PinDefinition.js";
 export class NetGraph {
@@ -232,7 +232,7 @@ export class NetGraph {
         const netsLength = netsIndexed.length;
         const conductanceMatrix = Matrix.zeros(netsLength, netsLength);
         components.forEach(item => {
-            if (item.typeProp === TypeProps.Resistor) {
+            if (item.typeProp === ComponentTypes.resistor) {
                 const net1 = item.pinNets.get(1);
                 const net2 = item.pinNets.get(2);
                 const net1Index = netsIndexed.indexOf(net1);