circuitscript 0.0.21 → 0.0.24

package/dist/types/geometry.d.ts

@@ -0,0 +1,84 @@
+import Flatten from '@flatten-js/core';
+import { Box } from '@svgdotjs/svg.js';
+export type Segment = Flatten.Segment;
+export type Polygon = Flatten.Polygon;
+export type Multiline = Flatten.Multiline;
+export type Line = Flatten.Line;
+export type Arc = Flatten.Arc;
+export type Feature = Segment | Polygon | Label | Arc | Multiline;
+export type LabelStyle = {
+    font?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    angle?: number;
+    anchor?: HorizontalAlign.Left | HorizontalAlign.Middle | HorizontalAlign.Right;
+    vanchor?: VerticalAlign.Top | VerticalAlign.Middle | VerticalAlign.Bottom;
+};
+export declare class Label extends Flatten.Polygon {
+    id: string;
+    text: string;
+    anchorPoint: [number, number];
+    boundingBox: {
+        width: number;
+        height: number;
+    };
+    polygon: Polygon;
+    font: string;
+    style: LabelStyle;
+    textMeasurementBounds: Box;
+    get box(): Flatten.Box;
+    constructor(id: string, text: string, anchorPoint: [number, number], polygon: Flatten.Polygon, style: LabelStyle, bounds: Box);
+    static fromPoint(id: string, x: number, y: number, text: string, style: LabelStyle): Label;
+    rotate(angle: number, origin: Flatten.Point): Label;
+    getLabelPosition(): [number, number];
+}
+export declare class GeometryProp {
+    name: string;
+    value: string | number;
+    constructor(name: any, value: any);
+}
+export declare class Geometry {
+    static point(x: number, y: number): Flatten.Point;
+    static line(x1: number, y1: number, x2: number, y2: number): Flatten.Line;
+    static label(id: string, x: number, y: number, text: string, style: LabelStyle): Label;
+    static segment(start: [number, number], end: [number, number]): Segment;
+    static polygon(coords: [number, number][]): Polygon;
+    static multiline(coords: [number, number][]): Multiline;
+    static arc(center: [x: number, y: number], radius: number, startAngle: number, endAngle: number, sweepDirection: boolean): Arc;
+    static getCoords(item: Feature): [number, number][];
+    static rotateDegs(feature: Feature, angleDegrees: number, center: [number, number]): Feature;
+    static groupRotate(features: Feature[], angle: number, center: [number, number]): Feature[];
+    static groupBounds(features: Feature[]): {
+        start: [number, number];
+        end: [number, number];
+        width: number;
+        height: number;
+    };
+    static getType(feature: Feature): string;
+    static FullCircleRadians: number;
+    static featuresToPath(items: Feature[]): {
+        path: string;
+        isClosedPolygon: boolean;
+    };
+    static angle(dx: number, dy: number): number;
+    static getQuadrant(dx: number, dy: number): number;
+    static mergeWires(wirePoints: {
+        x: number;
+        y: number;
+    }[][]): {
+        intersectPoints: WirePointCount[];
+        segments: [x: number, y: number][][];
+    };
+}
+type WirePointCount = [x: number, y: number, count: number];
+export declare enum HorizontalAlign {
+    Left = "left",
+    Middle = "middle",
+    Right = "right"
+}
+export declare enum VerticalAlign {
+    Top = "top",
+    Middle = "middle",
+    Bottom = "bottom"
+}
+export {};

package/dist/types/globals.d.ts

@@ -0,0 +1,50 @@
+export declare enum GlobalNames {
+    __root = "__root",
+    gnd = "gnd",
+    DefaultResistor = "res",
+    DefaultCapacitor = "cap",
+    DefaultInductor = "ind",
+    symbol = "symbol"
+}
+export declare const NoNetText = "NO_NET";
+export declare enum ParamKeys {
+    __is_net = "__is_net",
+    __is_label = "__is_label",
+    priority = "priority",
+    net_name = "net_name"
+}
+export declare enum LayoutDirection {
+    RIGHT = "RIGHT",
+    LEFT = "LEFT"
+}
+export declare enum SymbolPinSide {
+    Left = "left",
+    Right = "right"
+}
+export declare const portWidth = 20;
+export declare const portHeight = 2;
+export declare const defaultFont = "Open Sans-Regular, Arial";
+export declare const defaultFontBold = "Open Sans-Bold, Arial-Bold, Arial";
+export declare const defaultFontSize = 10;
+export declare const bodyColor = "#FFFEAF";
+export declare const junctionSize = 5;
+export declare const junctionColor = "rgb(0, 132, 0)";
+export declare const wireColor = "rgb(0, 132, 0)";
+export declare enum ComponentTypes {
+    gnd = "gnd",
+    net = "net",
+    label = "label",
+    point = "point"
+}
+export declare enum ReferenceTypes {
+    function = "function",
+    value = "value",
+    variable = "variable",
+    instance = "instance"
+}
+export declare enum BlockTypes {
+    Branch = 1,
+    Join = 2,
+    Parallel = 3,
+    Point = 4
+}

package/dist/types/helpers.d.ts

@@ -0,0 +1,9 @@
+export declare enum JSModuleType {
+    CommonJs = "cjs",
+    ESM = "mjs"
+}
+export declare function renderScript(scriptData: string, outputPath: string, options: any): string;
+export declare function detectJSModuleType(): JSModuleType;
+export declare function getCurrentPath(): {
+    filePath: string;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from './draw_symbols.js';
+export * from './execute.js';
+export * from './export.js';
+export * from './geometry.js';
+export * from './globals.js';
+export * from './helpers.js';
+export * from './layout.js';
+export * from './lexer.js';
+export * from './logger.js';
+export * from './parser.js';
+export * from './render.js';
+export * from './utils.js';
+export * from './visitor.js';

package/dist/types/layout.d.ts

@@ -0,0 +1,147 @@
+import { Graph, Edge } from '@dagrejs/graphlib';
+import { SymbolGraphic, SymbolText } from "./draw_symbols.js";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { SequenceItem } from "./objects/ExecutionScope.js";
+import { WireSegment } from './objects/Wire.js';
+import { Net } from './objects/Net.js';
+import { Logger } from './logger.js';
+import { Frame, FramePlotDirection } from './objects/Frame.js';
+import { BoundBox } from './utils.js';
+export declare class LayoutEngine {
+    logger: Logger;
+    placeSubgraphVersion: number;
+    layoutWarnings: string[];
+    constructor();
+    protected print(...params: any[]): void;
+    protected printLevel(level: number, ...params: any[]): void;
+    protected padLevel(value: number): string;
+    runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
+        components: RenderComponent[];
+        wires: RenderWire[];
+        junctions: RenderJunction[];
+        mergedWires: MergedWire[];
+        frameObjects: RenderFrame[];
+        textObjects: RenderText[];
+    };
+    findJunctions(wireGroups: Map<string, RenderWire[]>): {
+        junctions: RenderJunction[];
+        mergedWires: MergedWire[];
+    };
+    placeFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frameObjects: RenderFrame[]): {
+        elementFrames: RenderFrame[];
+        textObjects: RenderText[];
+    };
+    collectElementFrames(frame: RenderFrame, level?: number): RenderFrame[];
+    applyFrameOffset(frame: RenderFrame, level?: number): void;
+    placeAndSizeFrame(frame: RenderFrame, level?: number): void;
+    dumpFrame(frame: RenderFrame, level?: number): void;
+    prepareFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frame: RenderFrame, level?: number): {
+        elementFrames: RenderFrame[];
+        textObjects: RenderText[];
+    };
+    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
+        graph: Graph;
+        containerFrames: RenderFrame[];
+    };
+    setGraphEdge(graph: Graph, node1: string, node2: string, edgeValue: EdgeValue): void;
+    sizeSubGraphs(graph: Graph): SubGraphInfo[];
+    walkAndPlaceGraph(graph: Graph, firstNodeId: string, subgraphNodes: string[]): void;
+    placeSubgraphV2(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
+    mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
+    placeSubgraph(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
+    translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
+    placeNodeAtPosition(fromX: number, fromY: number, item: RenderItem, pin: number, depth?: number): void;
+    placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
+    printWarnings(): void;
+}
+type EdgeValue = [
+    instance1: string,
+    instancePin1: number,
+    instance2: string,
+    instancePin2: number,
+    priority: number
+];
+type RenderItem = RenderComponent | RenderWire | RenderText;
+export declare function getBounds(components: (RenderComponent | RenderText)[], wires: RenderWire[], junctions: RenderJunction[], frames: RenderFrame[]): BoundBox;
+export declare class RenderObject {
+    x: number;
+    y: number;
+    isFloating: boolean;
+    floatingRelativeTo: [selfPin: number, nodeId: string, pin: number][];
+}
+export declare class RenderWire extends RenderObject {
+    id: number;
+    segments: WireSegment[];
+    points: {
+        x: number;
+        y: number;
+    }[];
+    netName: string;
+    constructor(x: number, y: number, segments: WireSegment[]);
+    refreshPoints(): void;
+    getAutoPoints(value: [x: number, y: number], direction: 'auto' | 'auto_'): [dx: number, dy: number][];
+    getWireEnd(): {
+        x: number;
+        y: number;
+    };
+    isEndAutoLength(): boolean;
+    getEndAuto(): [instance: ClassComponent, pin: number];
+    setEndAuto(untilX: number, untilY: number): void;
+    toString(): string;
+}
+export type MergedWire = {
+    netName: string;
+    segments: [x: number, y: number][][];
+    intersectPoints: [x: number, y: number, count: number][];
+};
+export declare class RenderComponent extends RenderObject {
+    component: ClassComponent;
+    symbol: SymbolGraphic;
+    width: number;
+    height: number;
+    displaySymbol: string | null;
+    constructor(component: ClassComponent, width: number, height: number);
+    doesOverlap(other: RenderComponent): boolean;
+    toString(): string;
+}
+export declare class RenderText extends RenderObject {
+    symbol: SymbolText;
+    _fontSize: number;
+    _fontWeight: string;
+    get fontSize(): number;
+    set fontSize(value: number);
+    get fontWeight(): string;
+    set fontWeight(value: string);
+    constructor(text: string);
+}
+export declare class RenderFrame extends RenderObject {
+    bounds: BoundBox | null;
+    frame: Frame;
+    innerItems: (RenderComponent | RenderFrame | RenderText)[];
+    translateX: number;
+    translateY: number;
+    padding: number;
+    gap: number;
+    direction: FramePlotDirection;
+    borderWidth: number;
+    subgraphId: string;
+    type: RenderFrameType;
+    containsTitle: boolean;
+    constructor(frame: Frame, type?: RenderFrameType);
+    toString(): string;
+}
+export declare enum RenderFrameType {
+    Container = 1,
+    Elements = 2
+}
+export declare class RenderJunction {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+}
+type SubGraphInfo = {
+    firstNodeId: string;
+    components: string[];
+    bounds: BoundBox;
+};
+export { BoundBox };

package/dist/types/lexer.d.ts

@@ -0,0 +1,19 @@
+import { CharStream, Token } from "antlr4";
+import CircuitScriptLexer from "./antlr/CircuitScriptLexer.js";
+export declare class MainLexer extends CircuitScriptLexer {
+    tokens: any[];
+    indents: any[];
+    opened: number;
+    constructor(input: CharStream);
+    reset(): void;
+    emitToken(token: Token): void;
+    nextToken(): Token;
+    createDedent(): Token;
+    getCharIndex(): number;
+    commonToken(type: number, text: string): Token;
+    getIndentationCount(whitespace: string): number;
+    atStartOfInput(): boolean;
+    openBrace(): void;
+    closeBrace(): void;
+    onNewLine(): void;
+}

package/dist/types/logger.d.ts

@@ -0,0 +1,6 @@
+export declare class Logger {
+    logs: string[];
+    constructor();
+    add(message: string): void;
+    dump(): string;
+}

package/dist/types/main.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export default function main(): Promise<void>;

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

@@ -0,0 +1,40 @@
+import { SymbolDrawingCommands } from '../draw_symbols.js';
+import { Net } from './Net.js';
+import { PinDefinition, PinId } from './PinDefinition.js';
+import { WireSegment } from './Wire.js';
+export declare class ClassComponent {
+    instanceName: string;
+    numPins: number;
+    parameters: Map<string, number | string>;
+    pins: Map<number, PinDefinition>;
+    pinNets: Map<number, Net>;
+    pinWires: Map<number, WireSegment[]>;
+    _cachedPins: string;
+    _cachedParams: string;
+    className: string;
+    _copyID?: number;
+    _copyFrom?: ClassComponent;
+    arrangeProps: Map<string, number[]> | null;
+    displayProp: string | SymbolDrawingCommands | null;
+    widthProp: number | null;
+    typeProp: string | null;
+    styles: {
+        [key: string]: number | string;
+    };
+    assignedRefDes: string | null;
+    constructor(instanceName: string, numPins: number, className: string);
+    setupPins(): void;
+    getDefaultPin(): number;
+    hasPin(pinId: number | string): boolean;
+    getPin(pinId: number | string): PinId;
+    getNextPinAfter(pinIndex: number): number;
+    setParam(key: string, value: number | string): void;
+    private refreshParamCache;
+    private refreshPinsCache;
+    refreshCache(): void;
+    getParam(key: string): number | string;
+    toString(): string;
+    static simple(instanceName: string, numPins: number, className: string): ClassComponent;
+    isEqual(other: ClassComponent): boolean;
+    clone(): ClassComponent;
+}

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

@@ -0,0 +1,64 @@
+import { ClassComponent } from './ClassComponent.js';
+import { Net } from './Net.js';
+import { CFunction, ComponentPinNet, ComponentPinNetPair, ValueType } from './types.js';
+import { LayoutDirection } from '../globals.js';
+import { Wire, WireSegment } from './Wire.js';
+import { Frame } from './Frame.js';
+export declare class ExecutionScope {
+    scopeId: number;
+    private nets;
+    instances: Map<string, ClassComponent>;
+    functions: Map<string, CFunction>;
+    variables: Map<string, ValueType | ClassComponent>;
+    blockStack: Map<number, any>;
+    wires: Wire[];
+    frames: Frame[];
+    indentLevel: number;
+    netCounter: number;
+    unnamedCounter: number;
+    currentComponent: ClassComponent | null;
+    currentPin: number | null;
+    currentWireId: number;
+    currentFrameId: number;
+    netGnd: Net | null;
+    componentGnd: ClassComponent | null;
+    componentRoot: ClassComponent | null;
+    copyIDs: Map<string, number>;
+    sequence: any[];
+    constructor(scopeId: number);
+    static scopeId: number;
+    static create(): ExecutionScope;
+    private findNet;
+    getNetWithName(name: string): Net;
+    hasNet(component: ClassComponent, pin: number): boolean;
+    getNet(component: ClassComponent, pin: number): Net;
+    setNet(component: ClassComponent, pin: number, net: Net): void;
+    removeNet(component: ClassComponent, pin: number): void;
+    getNets(): ComponentPinNetPair[];
+    dumpNets(): ComponentPinNet[];
+    printNets(): void;
+    setActive(type: ActiveObject, item: any): void;
+    clearActive(): void;
+}
+export declare enum SequenceAction {
+    To = "to",
+    At = "at",
+    Wire = "wire",
+    WireJump = "wire-jump",
+    Frame = "frame"
+}
+export declare enum FrameAction {
+    Enter = "enter",
+    Exit = "exit"
+}
+export declare enum ActiveObject {
+    Frame = "frame",
+    Wire = "wire"
+}
+export type SequenceItem = [
+    SequenceAction.To | SequenceAction.At,
+    ClassComponent,
+    number,
+    LayoutDirection?,
+    string?
+] | [SequenceAction.Wire, wireId: number, WireSegment[]] | [SequenceAction.WireJump, wireId: number, pinId: number] | [SequenceAction.Frame, Frame, "enter" | "exit"];

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

@@ -0,0 +1,15 @@
+export declare class Frame {
+    parameters: Map<string, any>;
+    frameId: number;
+    constructor(frameId: number);
+}
+export declare enum FrameParamKeys {
+    Title = "title",
+    Direction = "direction",
+    Padding = "padding",
+    Border = "border"
+}
+export declare enum FramePlotDirection {
+    Row = "row",
+    Column = "column"
+}

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

@@ -0,0 +1,10 @@
+export declare class Net {
+    name: string;
+    baseName: string;
+    namespace: string;
+    priority: number;
+    type: any;
+    constructor(namespace: string, name: string, priority?: number, type?: any);
+    toString(): string;
+    static isSame(netA: Net, netB: Net): boolean;
+}

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

@@ -0,0 +1,20 @@
+export declare class ParamDefinition {
+    paramName: string;
+    paramValue: string | number | any;
+    constructor(paramName: string, paramValue: any);
+}
+export declare class NumericValue {
+    value: string | number;
+    constructor(value: string | number);
+    toString(): string;
+    toDisplayString(): string;
+}
+export declare class PercentageValue {
+    value: string | number;
+    constructor(value: string | number);
+    toString(): string;
+}
+export declare class PinBlankValue {
+    blank: number;
+    constructor(value: number);
+}

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

@@ -0,0 +1,24 @@
+import { PinTypes } from './PinTypes.js';
+export type PinId = number | string;
+export declare class PinDefinition {
+    id: PinId;
+    idType: PinIdType;
+    pinType: PinTypes;
+    name: string;
+    altNames: string[];
+    side: string;
+    position: number;
+    constructor(id: PinId, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
+}
+export declare enum PinIdType {
+    Int = "int",
+    Str = "str"
+}
+export declare enum PortSide {
+    WEST = "WEST",
+    EAST = "EAST",
+    SOUTH = "SOUTH",
+    NORTH = "NORTH"
+}
+export declare class PinReference {
+}

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

@@ -0,0 +1,7 @@
+export declare enum PinTypes {
+    Any = "any",
+    Input = "input",
+    Output = "output",
+    IO = "io",
+    Power = "power"
+}

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

@@ -0,0 +1,11 @@
+import { ClassComponent } from "./ClassComponent.js";
+export declare class Wire {
+    path: WireSegment[];
+    constructor(path: WireSegment[]);
+}
+export type WireSegment = {
+    direction: 'up' | 'down' | 'left' | 'right' | 'auto' | 'auto_';
+    value: number;
+    valueXY?: [x: number, y: number];
+    until?: [instance: ClassComponent, pin: number];
+};

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

@@ -0,0 +1,49 @@
+import { ExecutionContext } from '../execute.js';
+import { ClassComponent } from './ClassComponent.js';
+import { Net } from './Net.js';
+import { NumericValue, PercentageValue, PinBlankValue } from './ParamDefinition.js';
+export type CFunction = (args: CallableParameter[], options?: CFunctionOptions) => CFunctionResult;
+export type CFunctionOptions = {
+    netNamespace?: string;
+};
+export type CFunctionResult = [
+    executionContext: ExecutionContext,
+    result: ValueType | ClassComponent | null
+];
+export type ComponentPinNet = [
+    netName: string,
+    instanceName: string,
+    pin: number
+];
+export type ComponentPinNetPair = [
+    component: ClassComponent,
+    pin: number,
+    net: Net
+];
+export type ComponentPin = [
+    component: ClassComponent,
+    pinId: number | string
+];
+export type ComplexType = ValueType | ClassComponent | UndeclaredReference | null;
+export type ValueType = boolean | number | string | NumericValue | PercentageValue | PinBlankValue;
+export type CallableParameter = [
+    'keyword',
+    key: string,
+    value: ValueType
+] | [
+    'position',
+    key: number,
+    value: ValueType
+];
+export type FunctionDefinedParameter = [name: string, defaultValue: ValueType] | [name: string];
+export declare class UndeclaredReference {
+    reference: ReferenceType;
+    constructor(reference: ReferenceType);
+}
+export type ReferenceType = {
+    found: boolean;
+    name?: string;
+    trailers?: string[];
+    type?: string;
+    value?: any;
+};

package/dist/types/parser.d.ts

@@ -0,0 +1,38 @@
+import { ErrorListener, ParseTreeVisitor, ParserRuleContext, TerminalNode } from 'antlr4';
+import CircuitScriptLexer from './antlr/CircuitScriptLexer.js';
+import CircuitScriptParser, { ScriptContext } from './antlr/CircuitScriptParser.js';
+import { MainVisitor } from './visitor.js';
+export declare function parseFileWithVisitor(visitor: MainVisitor, data: string): {
+    tree: ScriptContext;
+    parser: CircuitScriptParser;
+    hasError: boolean;
+    hasParseError: boolean;
+    parserTimeTaken: number;
+    lexerTimeTaken: number;
+    tokens: IParsedToken[];
+};
+export declare class SemanticTokensVisitor extends ParseTreeVisitor<any> {
+    parsedTokens: IParsedToken[];
+    lexer: CircuitScriptLexer;
+    script: string;
+    semanticTokens: Map<string, IParsedToken>;
+    constructor(lexer: CircuitScriptLexer, script: string);
+    visit(ctx: ParserRuleContext): any;
+    handleError(ctx: ParserRuleContext, err: Error): void;
+    checkContext(ctx: ParserRuleContext): void;
+    addSemanticToken(parsedToken: IParsedToken): void;
+    parseToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): IParsedToken;
+}
+export interface IParsedToken {
+    line: number;
+    column: number;
+    length: number;
+    tokenType: string;
+    tokenModifiers: string[];
+    textValue: string;
+}
+export declare class CircuitscriptParserErrorListener extends ErrorListener {
+    syntaxErrorCounter: number;
+    syntaxError(recognizer: any, offendingSymbol: any, line: number, column: number, msg: string, e: any | undefined): void;
+    hasParseErrors(): boolean;
+}

package/dist/types/regenerate-tests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/render.d.ts

@@ -0,0 +1,10 @@
+import { BoundBox, MergedWire, RenderComponent, RenderFrame, RenderJunction, RenderText, RenderWire } from "./layout.js";
+export declare function generateSVG2(graph: {
+    components: RenderComponent[];
+    wires: RenderWire[];
+    junctions: RenderJunction[];
+    mergedWires: MergedWire[];
+    debugRects?: BoundBox[];
+    frameObjects: RenderFrame[];
+    textObjects: RenderText[];
+}): string;

package/dist/types/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/sizing.d.ts

@@ -0,0 +1,15 @@
+import { Box, SVGTypeMapping } from '@svgdotjs/svg.js';
+import { HorizontalAlign, VerticalAlign } from './geometry.js';
+import { SVGWindow } from 'svgdom';
+export declare function prepareSVGEnvironment(fontsPath: string | null): Promise<void>;
+export declare function getCreateSVGWindow(): () => SVGWindow;
+export declare function applyFontsToSVG(canvas: SVGTypeMapping): void;
+export declare function measureTextSize(text: string, fontFamily: string, fontSize: number): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function measureTextSize2(text: string, fontFamily: string, fontSize: number, fontWeight?: string, anchor?: HorizontalAlign, vanchor?: VerticalAlign): {
+    width: number;
+    height: number;
+    box: Box;
+};