circuitscript 0.1.4 → 0.1.7

package/dist/esm/helpers.mjs

@@ -1,380 +0,0 @@
-import { readFileSync, writeFileSync, createWriteStream } from "fs";
-import path from "path";
-import PDFDocument from "pdfkit";
-import { generateKiCADNetList, printTree } from "./export.mjs";
-import { LayoutEngine } from "./layout.mjs";
-import { SequenceAction } from "./objects/ExecutionScope.mjs";
-import { parseFileWithVisitor } from "./parser.mjs";
-import { generatePdfOutput, generateSvgOutput, renderSheetsToSVG } from "./render.mjs";
-import { resolveToNumericValue, SimpleStopwatch } from "./utils.mjs";
-import { ParserVisitor, VisitorExecutionException } from "./visitor.mjs";
-import { createContext } from "this-file";
-import { SymbolValidatorResolveVisitor, SymbolValidatorVisitor } from "./SymbolValidatorVisitor.mjs";
-import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy } from "antlr4ng";
-import { MainLexer } from "./lexer.mjs";
-import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
-import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.mjs";
-import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } from "./globals.mjs";
-import { FrameParamKeys } from "./objects/Frame.mjs";
-import Big from "big.js";
-import { Logger } from "./logger.mjs";
-export var JSModuleType;
-(function (JSModuleType) {
-    JSModuleType["CommonJs"] = "cjs";
-    JSModuleType["ESM"] = "mjs";
-})(JSModuleType || (JSModuleType = {}));
-export function prepareFile(textData) {
-    const chars = CharStream.fromString(textData);
-    const lexer = new MainLexer(chars);
-    const lexerTimer = new SimpleStopwatch();
-    const tokens = new CommonTokenStream(lexer);
-    tokens.fill();
-    const lexerTimeTaken = lexerTimer.lap();
-    const parser = new CircuitScriptParser(tokens);
-    return {
-        parser,
-        lexer,
-        lexerTimeTaken,
-        tokens
-    };
-}
-export function getScriptText(filePath) {
-    try {
-        return readFileSync(filePath, { encoding: 'utf-8' });
-    }
-    catch (err) {
-        return null;
-    }
-}
-export function getSemanticTokens(scriptData, options) {
-    const { parser, lexer, tokens } = prepareFile(scriptData);
-    const tree = parser.script();
-    const { currentDirectory = null, defaultLibsPath, } = options;
-    const visitor = new SemanticTokensVisitor(true, null, currentDirectory, defaultLibsPath, lexer, scriptData);
-    parser.removeErrorListeners();
-    visitor.onImportFile = (visitor, textData) => {
-        let hasError = false;
-        let hasParseError = false;
-        if (textData !== null) {
-            const { parser } = prepareFile(textData);
-            const tree = parser.script();
-            try {
-                visitor.visit(tree);
-            }
-            catch (err) {
-                console.log('Error while parsing: ', err);
-                hasParseError = true;
-                hasError = true;
-            }
-        }
-        else {
-            console.log('File does not exist');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    visitor.visit(tree);
-    const semanticTokens = visitor.getTokens();
-    const parsedTokens = prepareTokens(tokens.getTokens(), lexer, scriptData);
-    const finalParsedTokens = [];
-    parsedTokens.forEach(token => {
-        const location = `${token.line}_${token.column}`;
-        if (semanticTokens.has(location)) {
-            finalParsedTokens.push(semanticTokens.get(location));
-        }
-        else {
-            finalParsedTokens.push(token);
-        }
-    });
-    return {
-        visitor,
-        parsedTokens: finalParsedTokens
-    };
-}
-class TokenErrorListener extends BaseErrorListener {
-    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        console.log(msg);
-    }
-}
-export class ParseErrorStrategy extends DefaultErrorStrategy {
-    reportUnwantedToken(recognizer) {
-        if (this.inErrorRecoveryMode(recognizer)) {
-            return;
-        }
-        this.beginErrorCondition(recognizer);
-        const t = recognizer.getCurrentToken();
-        const tokenName = this.getTokenErrorDisplay(t);
-        const msg = "extraneous input " + tokenName;
-        recognizer.notifyErrorListeners(msg, t, null);
-        this.endErrorCondition(recognizer);
-    }
-}
-export function validateScript(scriptData, options) {
-    const { parser } = prepareFile(scriptData);
-    parser.removeErrorListeners();
-    parser.errorHandler = new ParseErrorStrategy();
-    parser.addErrorListener(new TokenErrorListener());
-    const tree = parser.script();
-    const { currentDirectory = null, defaultLibsPath, } = options;
-    const visitor = new SymbolValidatorVisitor(true, null, currentDirectory, defaultLibsPath);
-    visitor.onImportFile = (visitor, textData) => {
-        let hasError = false;
-        let hasParseError = false;
-        if (textData !== null) {
-            const { parser } = prepareFile(textData);
-            const tree = parser.script();
-            try {
-                visitor.visit(tree);
-            }
-            catch (err) {
-                console.log('got an error while parsing tree: ', err);
-                hasParseError = true;
-                hasError = true;
-            }
-        }
-        else {
-            console.log('file does not exist!');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    visitor.visit(tree);
-    const symbolTable = visitor.getSymbols();
-    symbolTable.clearUndefined();
-    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, currentDirectory, defaultLibsPath);
-    visitorResolver.setSymbols(visitor.getSymbols());
-    visitorResolver.onImportFile = visitor.onImportFile;
-    visitorResolver.visit(tree);
-    return visitorResolver;
-}
-export function renderScript(scriptData, outputPath, options) {
-    const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, showStats = false } = options;
-    const onErrorHandler = (line, column, message, error) => {
-        if (error instanceof VisitorExecutionException) {
-            console.log('Error', line, column, message, error.errorMessage);
-        }
-    };
-    const visitor = new ParserVisitor(true, onErrorHandler, currentDirectory, defaultLibsPath);
-    visitor.onImportFile = (visitor, fileData) => {
-        const { hasError, hasParseError } = parseFileWithVisitor(visitor, fileData);
-        return { hasError, hasParseError };
-    };
-    visitor.log('reading file');
-    visitor.log('done reading file');
-    const { tree, parser, hasParseError, hasError, parserTimeTaken, lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    if (dumpNets) {
-        const nets = visitor.dumpNets();
-        console.log(nets);
-    }
-    dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
-    dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
-    if (hasError || hasParseError) {
-        console.log('Error while parsing');
-        return null;
-    }
-    const { frameComponent } = visitor.applySheetFrameComponent();
-    try {
-        visitor.annotateComponents();
-    }
-    catch (err) {
-        console.log('Error during annotation: ', err);
-    }
-    const { sequence, nets } = visitor.getGraph();
-    const tmpSequence = sequence.map(item => {
-        const tmp = [...item];
-        const action = tmp[0];
-        if (action === SequenceAction.Wire) {
-            tmp[2] = tmp[2].map(item2 => {
-                const lengthValue = item2.value;
-                const useValue = [item2.direction];
-                if (lengthValue !== null) {
-                    useValue.push(lengthValue.value);
-                    useValue.push(lengthValue.type);
-                }
-                return useValue.join(",");
-            }).join(" ");
-        }
-        else if (action === SequenceAction.Frame) {
-            tmp[1] = item[1].frameId;
-        }
-        else if (action !== SequenceAction.WireJump) {
-            tmp[1] = item[1].instanceName;
-        }
-        return tmp.join(" | ");
-    });
-    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
-    let svgOutput = "";
-    try {
-        let fileExtension = null;
-        let outputDefaultZoom = defaultZoomScale;
-        if (outputPath) {
-            fileExtension = path.extname(outputPath).substring(1);
-            if (fileExtension === "pdf") {
-                outputDefaultZoom = 1;
-            }
-        }
-        if (fileExtension === 'net') {
-            const { tree: kicadNetList, missingFootprints } = generateKiCADNetList(visitor.getNetList());
-            missingFootprints.forEach(entry => {
-                console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
-            });
-            writeFileSync(outputPath, printTree(kicadNetList));
-            console.log('Generated file', outputPath);
-            return null;
-        }
-        const layoutEngine = new LayoutEngine();
-        const layoutTimer = new SimpleStopwatch();
-        const sheetFrames = layoutEngine.runLayout(sequence, nets);
-        layoutEngine.printWarnings();
-        showStats && console.log('Layout took:', layoutTimer.lap());
-        dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
-        const generateSvgTimer = new SimpleStopwatch();
-        const renderLogger = new Logger();
-        const svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger);
-        showStats && console.log('Render took:', generateSvgTimer.lap());
-        dumpData && writeFileSync('dump/raw-render.txt', renderLogger.dump());
-        svgOutput = generateSvgOutput(svgCanvas, outputDefaultZoom);
-        if (outputPath) {
-            if (fileExtension === 'svg') {
-                writeFileSync(outputPath, svgOutput);
-            }
-            else if (fileExtension === 'pdf') {
-                let sheetSize = "A4";
-                let sheetSizeDefined = false;
-                if (frameComponent) {
-                    sheetSize = frameComponent.getParam(FrameParamKeys.PaperSize);
-                    sheetSizeDefined = true;
-                }
-                const doc = new PDFDocument({
-                    layout: 'landscape',
-                    size: sheetSize
-                });
-                const outputStream = createWriteStream(outputPath);
-                generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
-                doc.pipe(outputStream);
-                doc.end();
-            }
-            else {
-                throw "Invalid output format";
-            }
-            console.log('Generated file', outputPath);
-        }
-    }
-    catch (err) {
-        console.log('Error during render: ', err);
-    }
-    return svgOutput;
-}
-export function detectJSModuleType() {
-    if (typeof __filename === 'undefined' &&
-        typeof __dirname === 'undefined') {
-        return JSModuleType.ESM;
-    }
-    else {
-        return JSModuleType.CommonJs;
-    }
-}
-const context = createContext();
-export function getCurrentPath() {
-    const filename = context.filename;
-    return { filePath: filename };
-}
-function getToolsPath() {
-    const { filePath } = getCurrentPath();
-    return path.normalize(path.dirname(filePath) + '/../../');
-}
-export function getFontsPath() {
-    const toolsPath = getToolsPath();
-    return path.normalize(toolsPath + "fonts");
-}
-export function getDefaultLibsPath() {
-    const toolsPath = getToolsPath();
-    return path.normalize(toolsPath + "libs");
-}
-export function getPackageVersion() {
-    const packageJson = JSON.parse(readFileSync(getToolsPath() + 'package.json').toString());
-    const { version } = packageJson;
-    return version;
-}
-export class UnitDimension {
-    type;
-    value;
-    constructor(value, type = LengthUnit.mils) {
-        this.value = value;
-        this.type = type;
-    }
-    getMM() {
-        switch (this.type) {
-            case LengthUnit.mm:
-                return this.value;
-            case LengthUnit.mils:
-                return this.value * MilsToMM;
-            case LengthUnit.px:
-                return this.value * PxToMM;
-        }
-    }
-    static mm(value) {
-        return new UnitDimension(value, LengthUnit.mm);
-    }
-    static mils(value) {
-        return new UnitDimension(value, LengthUnit.mils);
-    }
-    static px(value) {
-        return new UnitDimension(value, LengthUnit.px);
-    }
-}
-export function milsToMM(value) {
-    if (typeof value === 'number') {
-        value = resolveToNumericValue(new Big(value));
-    }
-    return resolveToNumericValue(value.toBigNumber().mul(new Big(MilsToMM)).round(6));
-}
-export function pxToMM(value) {
-    return value * PxToMM;
-}
-const PaperSizes = {
-    'A0': [1189, 841],
-    'A1': [841, 594],
-    'A2': [594, 420],
-    'A3': [420, 297],
-    'A4': [297, 210],
-    'A5': [210, 148],
-    'A6': [148, 105],
-};
-export const PaperGridReferences = {
-    'A0': [16, 24],
-    'A1': [12, 16],
-    'A2': [8, 12],
-    'A3': [6, 8],
-    'A4': [4, 6],
-};
-export function isSupportedPaperSize(type) {
-    if (PaperSizes[type]) {
-        return true;
-    }
-    return false;
-}
-export function getPaperSize(type, margin = defaultPageMarginMM) {
-    if (PaperSizes[type]) {
-        const [width, height] = PaperSizes[type];
-        const useWidth = width - margin * 2;
-        const useHeight = height - margin * 2;
-        return {
-            width: Math.floor(useWidth * (1 / MilsToMM)),
-            height: Math.floor(useHeight * (1 / MilsToMM)),
-            widthMM: useWidth,
-            heightMM: useHeight,
-            originalWidthMM: width,
-            originalHeightMM: height,
-        };
-    }
-    else {
-        return getPaperSize('A4');
-    }
-}

package/dist/esm/index.mjs

@@ -1,15 +0,0 @@
-export * from './draw_symbols.mjs';
-export * from './execute.mjs';
-export * from './export.mjs';
-export * from './geometry.mjs';
-export * from './globals.mjs';
-export * from './helpers.mjs';
-export * from './layout.mjs';
-export * from './lexer.mjs';
-export * from './logger.mjs';
-export * from './parser.mjs';
-export * from './render.mjs';
-export * from './utils.mjs';
-export * from './visitor.mjs';
-export * from './sizing.mjs';
-export * from './objects/types.mjs';

package/dist/esm/parser.mjs

@@ -1,64 +0,0 @@
-import { CircuitScriptParser } from './antlr/CircuitScriptParser.mjs';
-import { MainLexer } from './lexer.mjs';
-import { SimpleStopwatch } from './utils.mjs';
-import { CharStream, CommonTokenStream, DefaultErrorStrategy } from 'antlr4ng';
-export function parseFileWithVisitor(visitor, data) {
-    const chars = CharStream.fromString(data);
-    const lexer = new MainLexer(chars);
-    const lexerTimer = new SimpleStopwatch();
-    const tokens = new CommonTokenStream(lexer);
-    tokens.fill();
-    const lexerTimeTaken = lexerTimer.lap();
-    const parserTimer = new SimpleStopwatch();
-    const parser = new CircuitScriptParser(tokens);
-    const tree = parser.script();
-    let hasError = false;
-    try {
-        visitor.visit(tree);
-    }
-    catch (err) {
-        console.log(err);
-        hasError = true;
-    }
-    const parserTimeTaken = parserTimer.lap();
-    return {
-        tree, parser,
-        hasParseError: false,
-        hasError,
-        parserTimeTaken,
-        lexerTimeTaken,
-    };
-}
-export class TempErrorStrategy extends DefaultErrorStrategy {
-    recover(recognizer, e) {
-        throw new Error('Method not implemented.');
-    }
-    reportError(recognizer, e) {
-        throw new Error('Method not implemented.');
-    }
-}
-export class CircuitscriptParserErrorListener {
-    syntaxErrorCounter = 0;
-    onErrorHandler = null;
-    constructor(onErrorHandler = null) {
-        this.onErrorHandler = onErrorHandler;
-    }
-    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
-        if (this.onErrorHandler) {
-            this.onErrorHandler(line, charPositionInLine, msg, e);
-        }
-        else {
-            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
-        }
-        this.syntaxErrorCounter++;
-    }
-    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
-    }
-    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
-    }
-    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
-    }
-    hasSyntaxErrors() {
-        return (this.syntaxErrorCounter > 0);
-    }
-}

package/dist/esm/utils.mjs

@@ -1,169 +0,0 @@
-import { Big } from 'big.js';
-import { NumericValue } from "./objects/ParamDefinition";
-export class SimpleStopwatch {
-    startTime;
-    constructor() {
-        this.startTime = new Date();
-    }
-    lap() {
-        return (new Date()).getTime() - this.startTime.getTime();
-    }
-}
-export function resizeBounds(bounds, value) {
-    return {
-        xmin: bounds.xmin - value,
-        xmax: bounds.xmax + value,
-        ymin: bounds.ymin - value,
-        ymax: bounds.ymax + value
-    };
-}
-export function printBounds(bounds) {
-    if (bounds !== null) {
-        return `[${bounds.xmin}, ${bounds.ymin} to ${bounds.xmax}, ${bounds.ymax}]`;
-    }
-    else {
-        return 'null';
-    }
-}
-function hasRemainder(value, value2) {
-    const tmpValue = Math.abs(value) / value2;
-    const flooredValue = Math.floor(tmpValue);
-    const diff = tmpValue - flooredValue;
-    return diff;
-}
-export function resizeToNearestGrid(bounds, gridSize = 20) {
-    const addXMin = hasRemainder(bounds.xmin, gridSize) === 0 ? -1 : 0;
-    const addYMin = hasRemainder(bounds.ymin, gridSize) === 0 ? -1 : 0;
-    const addXMax = hasRemainder(bounds.xmax, gridSize) === 0 ? 1 : 0;
-    const addYMax = hasRemainder(bounds.ymax, gridSize) === 0 ? 1 : 0;
-    return {
-        xmin: Math.floor((bounds.xmin + addXMin) / gridSize) * gridSize,
-        ymin: Math.floor((bounds.ymin + addYMin) / gridSize) * gridSize,
-        xmax: Math.ceil((bounds.xmax + addXMax) / gridSize) * gridSize,
-        ymax: Math.ceil((bounds.ymax + addYMax) / gridSize) * gridSize,
-    };
-}
-export function toNearestGrid(value, gridSize) {
-    return Math.floor(value / gridSize) * gridSize;
-}
-export function getBoundsSize(bounds) {
-    return {
-        width: bounds.xmax - bounds.xmin,
-        height: bounds.ymax - bounds.ymin,
-    };
-}
-export function getPortType(component) {
-    const drawingCommands = component.displayProp;
-    let foundPinType = null;
-    const commands = drawingCommands.getCommands();
-    commands.some(item => {
-        if (item[0] === 'label' && item[2].has('portType')) {
-            foundPinType = item[2].get('portType');
-            return true;
-        }
-        return false;
-    });
-    return foundPinType;
-}
-export function roundValue(value) {
-    return resolveToNumericValue(new Big(value.toBigNumber().toFixed(7)));
-}
-export function throwWithContext(context, message) {
-    const startLine = context.start?.line;
-    const startColumn = context.start?.column;
-    const startString = startLine + ":" + startColumn;
-    const stopLine = context.stop?.line;
-    const stopColumn = context.stop?.column;
-    let stopString = "";
-    if (startLine === stopLine) {
-        stopString = stopColumn?.toString();
-    }
-    else {
-        stopString = stopLine + ":" + stopString;
-    }
-    throw `Parse exception at [${startString} - ${stopString}] : ${message}`;
-}
-export function combineMaps(map1, map2) {
-    const newMap = new Map(map1);
-    map2.forEach((value, key) => {
-        newMap.set(key, value);
-    });
-    return newMap;
-}
-export function getNumberExponential(value) {
-    value = value.trim();
-    switch (value) {
-        case 'G':
-            return 9;
-        case 'M':
-            return 6;
-        case 'k':
-        case 'K':
-            return 3;
-        case 'm':
-            return -3;
-        case 'u':
-            return -6;
-        case 'n':
-            return -9;
-        case 'p':
-            return -12;
-        case 'f':
-            return -15;
-        default:
-            return 0;
-    }
-}
-export function getNumberExponentialText(value) {
-    switch (value) {
-        case -15:
-            return 'f';
-        case -12:
-            return 'p';
-        case -9:
-            return 'n';
-        case -6:
-            return 'u';
-        case -3:
-            return 'm';
-        case 3:
-            return 'k';
-        case 6:
-            return 'M';
-        case 9:
-            return 'G';
-        case 0:
-        default:
-            return '';
-    }
-}
-export function resolveToNumericValue(value) {
-    if (value.toNumber() === 0) {
-        return new NumericValue(0);
-    }
-    const isNeg = value.lt(0);
-    const positiveValue = isNeg ? value.neg() : value;
-    const prefixPart = Math.floor(Math.log10(positiveValue.toNumber()) / 3);
-    let useValue = value;
-    if (prefixPart !== 0) {
-        const tmpValue1 = positiveValue.div(Math.pow(10, prefixPart * 3));
-        useValue = isNeg ? tmpValue1.neg() : tmpValue1;
-    }
-    return new NumericValue(useValue, prefixPart * 3);
-}
-export function isPointWithinArea(point, bounds) {
-    const [xPt, yPt] = point;
-    const [xmin, ymin, xmax, ymax] = bounds;
-    return (xPt > xmin && xPt < xmax && yPt > ymin && yPt < ymax);
-}
-export function areasOverlap(area1, area2) {
-    const [xmin, ymin, xmax, ymax] = area1;
-    const pt1 = [xmin, ymin];
-    const pt2 = [xmin, ymax];
-    const pt3 = [xmax, ymin];
-    const pt4 = [xmax, ymax];
-    return isPointWithinArea(pt1, area2)
-        || isPointWithinArea(pt2, area2)
-        || isPointWithinArea(pt3, area2)
-        || isPointWithinArea(pt4, area2);
-}

package/dist/esm/validate.mjs

@@ -1,74 +0,0 @@
-#! /usr/bin/env node
-import { program } from 'commander';
-import figlet from 'figlet';
-import path from 'path';
-import { readFileSync } from 'fs';
-import { prepareSVGEnvironment } from './sizing.mjs';
-import { getCurrentPath, getScriptText, getSemanticTokens, validateScript } from './helpers.mjs';
-export async function validate() {
-    const { filePath } = getCurrentPath();
-    const toolSrcPath = filePath;
-    const toolDirectory = path.dirname(toolSrcPath) + '/../../';
-    const fontsPath = toolDirectory + '/fonts';
-    const defaultLibsPath = toolDirectory + '/libs';
-    const packageJson = JSON.parse(readFileSync(toolDirectory + 'package.json').toString());
-    ;
-    const { version } = packageJson;
-    program
-        .description('generate graphical output from circuitscript files')
-        .version(version)
-        .option('-i, --input text <input text>', 'Input text directly')
-        .option('-f, --input-file <path>', 'Input file')
-        .option('-o, --output <path>', 'Output path')
-        .option('-c, --current-directory <path>', 'Set current directory')
-        .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
-        .option('-w, --watch', 'Watch for file changes')
-        .option('-n, --dump-nets', 'Dump out net information')
-        .option('-d, --dump-data', 'Dump data during parsing')
-        .option('-s, --stats', 'Show stats during generation');
-    program.addHelpText('before', figlet.textSync('circuitscript', {
-        font: 'Small Slant'
-    }));
-    if (process.argv.length < 3) {
-        program.help();
-    }
-    program.parse();
-    const options = program.opts();
-    const watchFileChanges = options.watch;
-    const outputPath = options.output ?? null;
-    const dumpNets = options.dumpNets;
-    const dumpData = options.dumpData;
-    const kicadNetlist = options.kicadNetlist;
-    let currentDirectory = options.currentDirectory ?? null;
-    if (watchFileChanges) {
-        console.log('watching for file changes...');
-    }
-    await prepareSVGEnvironment(fontsPath);
-    let inputFilePath = null;
-    let scriptData;
-    if (options.input) {
-        scriptData = options.input;
-    }
-    else {
-        inputFilePath = options.inputFile;
-        const tmpScriptData = getScriptText(inputFilePath);
-        if (tmpScriptData === null) {
-            throw "File does not exists";
-        }
-        scriptData = tmpScriptData;
-        if (currentDirectory === null) {
-            currentDirectory = path.dirname(inputFilePath);
-        }
-    }
-    const scriptOptions = {
-        currentDirectory,
-        defaultLibsPath,
-        dumpNets,
-        dumpData,
-        kicadNetlistPath: kicadNetlist,
-        showStats: options.stats,
-    };
-    const visitor = validateScript(scriptData, scriptOptions);
-    const semanticTokensVisitor = getSemanticTokens(scriptData, scriptOptions);
-}
-validate();