@modular-circuit/perc 0.0.58 → 0.0.59

package/build/tester/graph/ir_graph_converter.js

@@ -1,279 +1,138 @@
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { ConnectionNodeType, LinkType, PortType, } from '@modular-circuit/electronics-model';
 import { PowerShape, } from '@modular-circuit/electronics-model';
 import { deep_copy, fmt_module_name, gen_uuid, get_circuit_ports, get_port_labels } from '@modular-circuit/utils';
-var IR_GRAPH_CONVERTER = /** @class */ (function () {
-    function IR_GRAPH_CONVERTER(circuits) {
+export class IR_GRAPH_CONVERTER {
+    circuits;
+    graph = {};
+    connection_node_map = {};
+    schematics = {};
+    reporter_context = {
+        pin_name_table: {},
+        pin_module_name_table: {},
+    };
+    get_report_context() {
+        return this.reporter_context;
+    }
+    constructor(circuits) {
         this.circuits = circuits;
-        this.graph = {};
-        this.connection_node_map = {};
-        this.schematics = {};
-        this.reporter_context = {
-            pin_name_table: {},
-            pin_module_name_table: {},
-        };
     }
-    IR_GRAPH_CONVERTER.prototype.get_report_context = function () {
-        return this.reporter_context;
-    };
-    IR_GRAPH_CONVERTER.prototype.convert_to_graph = function (designs) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h, e_9, _j;
-        var _k, _l, _m, _o, _p, _q, _r, _s, _t;
-        var errors = [];
+    convert_to_graph(designs) {
+        const errors = [];
         if (Object.keys(designs).length > 1) {
             throw new Error('Multiple designs are not supported');
         }
-        try {
-            // Blocks
-            for (var _u = __values(Object.entries(designs)), _v = _u.next(); !_v.done; _v = _u.next()) {
-                var _w = __read(_v.value, 2), sch_name = _w[0], design = _w[1];
-                this.schematics[sch_name] = { uuid: (_k = design.uuid) !== null && _k !== void 0 ? _k : gen_uuid(), sheets: [], powers: [] };
-                try {
-                    for (var _x = (e_2 = void 0, __values((_l = design.blocks) !== null && _l !== void 0 ? _l : [])), _y = _x.next(); !_y.done; _y = _x.next()) {
-                        var block = _y.value;
-                        var circuit = this.circuits[fmt_module_name(block.type)];
-                        this.schematics[sch_name].sheets.push({
-                            uuid: block.uuid,
-                            sheet_name: (_m = design.name) !== null && _m !== void 0 ? _m : circuit.name,
-                            sheet_file_name: circuit.main,
-                            ports: block.ports.map(function (p) { return p.uuid; }),
-                        });
-                        var port_map = get_circuit_ports(circuit);
-                        try {
-                            for (var _z = (e_3 = void 0, __values(block.ports)), _0 = _z.next(); !_0.done; _0 = _z.next()) {
-                                var port = _0.value;
-                                var param = deep_copy(port_map[port.index]);
-                                var uuid = port.uuid;
-                                this.add_node(uuid);
-                                this.connection_node_map[uuid] = {
-                                    uuid: uuid,
-                                    type: ConnectionNodeType.Port,
-                                    param: param,
-                                    label_shapes: get_port_labels(param, circuit),
-                                };
-                                this.reporter_context.pin_module_name_table[port.uuid] = block.type.name;
-                                this.reporter_context.pin_name_table[port.uuid] = port.name;
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_0 && !_0.done && (_c = _z.return)) _c.call(_z);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_y && !_y.done && (_b = _x.return)) _b.call(_x);
-                    }
-                    finally { if (e_2) throw e_2.error; }
+        // Blocks
+        for (const [sch_name, design] of Object.entries(designs)) {
+            this.schematics[sch_name] = { uuid: design.uuid ?? gen_uuid(), sheets: [], powers: [] };
+            for (const block of design.blocks ?? []) {
+                const circuit = this.circuits[fmt_module_name(block.type)];
+                this.schematics[sch_name].sheets.push({
+                    uuid: block.uuid,
+                    sheet_name: design.name ?? circuit.name,
+                    sheet_file_name: circuit.main,
+                    ports: block.ports.map((p) => p.uuid),
+                });
+                const port_map = get_circuit_ports(circuit);
+                for (const port of block.ports) {
+                    const param = deep_copy(port_map[port.index]);
+                    const uuid = port.uuid;
+                    this.add_node(uuid);
+                    this.connection_node_map[uuid] = {
+                        uuid,
+                        type: ConnectionNodeType.Port,
+                        param,
+                        label_shapes: get_port_labels(param, circuit),
+                    };
+                    this.reporter_context.pin_module_name_table[port.uuid] = block.type.name;
+                    this.reporter_context.pin_name_table[port.uuid] = port.name;
                 }
-                // Labels
-                var lb_map = {};
-                try {
-                    for (var _1 = (e_4 = void 0, __values((_o = design.labels) !== null && _o !== void 0 ? _o : [])), _2 = _1.next(); !_2.done; _2 = _1.next()) {
-                        var lb = _2.value;
-                        this.add_node(lb.uuid);
-                        this.reporter_context.pin_name_table[lb.uuid] = lb.text;
-                        lb_map[lb.text] = __spreadArray(__spreadArray([], __read(((_p = lb_map[lb.text]) !== null && _p !== void 0 ? _p : [])), false), [lb.uuid], false);
-                        switch (lb.type) {
-                            case 'label':
-                                this.connection_node_map[lb.uuid] = { uuid: lb.uuid, type: ConnectionNodeType.NetLabel, text: lb.text };
-                                break;
-                            default:
-                                throw new Error("Unsupported label type ".concat(lb.type));
-                        }
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (_2 && !_2.done && (_d = _1.return)) _d.call(_1);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-                try {
-                    for (var _3 = (e_5 = void 0, __values(Object.values(lb_map))), _4 = _3.next(); !_4.done; _4 = _3.next()) {
-                        var labels = _4.value;
-                        for (var i = 0; i < labels.length - 1; i++) {
-                            this.add_connection(labels[i], labels[i + 1]);
-                        }
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (_4 && !_4.done && (_e = _3.return)) _e.call(_3);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-                try {
-                    // POWER
-                    for (var _5 = (e_6 = void 0, __values((_q = design.pwr) !== null && _q !== void 0 ? _q : [])), _6 = _5.next(); !_6.done; _6 = _5.next()) {
-                        var pwr = _6.value;
-                        this.add_pwr(pwr, PowerShape.VCC, sch_name, {
-                            type: PortType.VoltageSource,
-                            name: pwr.value,
-                            link_type: LinkType.VoltageLink,
-                            label_associated: pwr.value,
-                            voltage_out: pwr.param ? pwr.param.voltage_out : {},
-                            current_limits: pwr.param ? pwr.param.current_limits : {},
-                        });
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (_6 && !_6.done && (_f = _5.return)) _f.call(_5);
-                    }
-                    finally { if (e_6) throw e_6.error; }
-                }
-                try {
-                    for (var _7 = (e_7 = void 0, __values((_r = design.gnd) !== null && _r !== void 0 ? _r : [])), _8 = _7.next(); !_8.done; _8 = _7.next()) {
-                        var pwr = _8.value;
-                        this.add_pwr(pwr, PowerShape.GND, sch_name, {
-                            type: PortType.Ground,
-                            name: pwr.value,
-                            link_type: LinkType.GroundLink,
-                            label_associated: pwr.value,
-                            voltage_limits: pwr.param ? pwr.param.voltage_limits : {},
-                        });
-                    }
-                }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (_8 && !_8.done && (_g = _7.return)) _g.call(_7);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-                try {
-                    // Junctions
-                    for (var _9 = (e_8 = void 0, __values((_s = design.junctions) !== null && _s !== void 0 ? _s : [])), _10 = _9.next(); !_10.done; _10 = _9.next()) {
-                        var j = _10.value;
-                        var uuid = j.uuid;
-                        this.add_node(uuid);
-                        this.connection_node_map[uuid] = { uuid: uuid, type: ConnectionNodeType.Graphics };
-                    }
-                }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                finally {
-                    try {
-                        if (_10 && !_10.done && (_h = _9.return)) _h.call(_9);
-                    }
-                    finally { if (e_8) throw e_8.error; }
-                }
-                try {
-                    // Connections
-                    for (var _11 = (e_9 = void 0, __values((_t = design.wires) !== null && _t !== void 0 ? _t : [])), _12 = _11.next(); !_12.done; _12 = _11.next()) {
-                        var connection = _12.value;
-                        var uuid = connection.uuid;
-                        this.add_connection(connection.from, connection.to);
-                        this.connection_node_map[uuid] = { uuid: uuid, type: ConnectionNodeType.Graphics };
-                    }
+            }
+            // Labels
+            const lb_map = {};
+            for (const lb of design.labels ?? []) {
+                this.add_node(lb.uuid);
+                this.reporter_context.pin_name_table[lb.uuid] = lb.text;
+                lb_map[lb.text] = [...(lb_map[lb.text] ?? []), lb.uuid];
+                switch (lb.type) {
+                    case 'label':
+                        this.connection_node_map[lb.uuid] = { uuid: lb.uuid, type: ConnectionNodeType.NetLabel, text: lb.text };
+                        break;
+                    default:
+                        throw new Error(`Unsupported label type ${lb.type}`);
                 }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (_12 && !_12.done && (_j = _11.return)) _j.call(_11);
-                    }
-                    finally { if (e_9) throw e_9.error; }
+            }
+            for (const labels of Object.values(lb_map)) {
+                for (let i = 0; i < labels.length - 1; i++) {
+                    this.add_connection(labels[i], labels[i + 1]);
                 }
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_v && !_v.done && (_a = _u.return)) _a.call(_u);
+            // POWER
+            for (const pwr of design.pwr ?? []) {
+                this.add_pwr(pwr, PowerShape.VCC, sch_name, {
+                    type: PortType.VoltageSource,
+                    name: pwr.value,
+                    link_type: LinkType.VoltageLink,
+                    label_associated: pwr.value,
+                    voltage_out: pwr.param ? pwr.param.voltage_out : {},
+                    current_limits: pwr.param ? pwr.param.current_limits : {},
+                });
+            }
+            for (const pwr of design.gnd ?? []) {
+                this.add_pwr(pwr, PowerShape.GND, sch_name, {
+                    type: PortType.Ground,
+                    name: pwr.value,
+                    link_type: LinkType.GroundLink,
+                    label_associated: pwr.value,
+                    voltage_limits: pwr.param ? pwr.param.voltage_limits : {},
+                });
+            }
+            // Junctions
+            for (const j of design.junctions ?? []) {
+                const uuid = j.uuid;
+                this.add_node(uuid);
+                this.connection_node_map[uuid] = { uuid, type: ConnectionNodeType.Graphics };
+            }
+            // Connections
+            for (const connection of design.wires ?? []) {
+                const uuid = connection.uuid;
+                this.add_connection(connection.from, connection.to);
+                this.connection_node_map[uuid] = { uuid, type: ConnectionNodeType.Graphics };
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return errors.length ? errors : true;
-    };
-    IR_GRAPH_CONVERTER.prototype.add_node = function (id) {
+    }
+    add_node(id) {
         if (!this.graph[id])
             this.graph[id] = new Set();
-    };
-    IR_GRAPH_CONVERTER.prototype.add_pwr = function (pwr, shape, sch_name, param) {
-        var uuid = pwr.uuid;
-        var value = pwr.value;
+    }
+    add_pwr(pwr, shape, sch_name, param) {
+        const uuid = pwr.uuid;
+        const value = pwr.value;
         this.add_node(uuid);
         this.reporter_context.pin_name_table[uuid] = pwr.value;
-        this.connection_node_map[uuid] = { uuid: uuid, type: ConnectionNodeType.Power, value: value, param: param };
+        this.connection_node_map[uuid] = { uuid, type: ConnectionNodeType.Power, value, param };
         this.schematics[sch_name].powers.push({
-            uuid: uuid,
-            value: value,
-            shape: shape,
+            uuid,
+            value,
+            shape,
         });
-    };
-    IR_GRAPH_CONVERTER.prototype.add_connection = function (from, to) {
-        this.do_add_connection({ from: from, to: to });
-    };
-    IR_GRAPH_CONVERTER.prototype.do_add_connection = function (conn) {
-        var e_10, _a;
-        try {
-            for (var _b = __values([conn.from, conn.to]), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var p = _c.value;
-                this.add_node(p);
-            }
-        }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_10) throw e_10.error; }
-        }
+    }
+    add_connection(from, to) {
+        this.do_add_connection({ from, to });
+    }
+    do_add_connection(conn) {
+        for (const p of [conn.from, conn.to])
+            this.add_node(p);
         this.graph[conn.from].add(conn.to);
         this.graph[conn.to].add(conn.from);
-    };
-    IR_GRAPH_CONVERTER.prototype.get_connection_node_map = function () {
+    }
+    get_connection_node_map() {
         return this.connection_node_map;
-    };
-    IR_GRAPH_CONVERTER.prototype.get_graph = function () {
+    }
+    get_graph() {
         return this.graph;
-    };
-    IR_GRAPH_CONVERTER.prototype.get_schematics = function () {
+    }
+    get_schematics() {
         return this.schematics;
-    };
-    return IR_GRAPH_CONVERTER;
-}());
-export { IR_GRAPH_CONVERTER };
+    }
+}

package/build/utils/get_dependent_modules_definition.js

@@ -1,145 +1,18 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
+import { fmt_module_name } from '@modular-circuit/utils';
+export async function get_dependent_modules_definition(ctx) {
+    const circuits = {};
+    for (const [, v] of Object.entries(ctx.schematics)) {
+        for (const block of v.blocks ?? []) {
+            const module_name = fmt_module_name(block.type);
+            const version = ctx.dependencies[module_name];
+            if (version === undefined) {
+                console.warn(`Module ${module_name} not found in dependencies`);
+                continue;
             }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
+            const def = await ctx.module_resolver.get_module_circuit({ ...block.type, version });
+            if (def)
+                circuits[module_name] = def;
         }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-import { fmt_module_name } from '@modular-circuit/utils';
-export function get_dependent_modules_definition(ctx) {
-    return __awaiter(this, void 0, void 0, function () {
-        var circuits, _a, _b, _c, v, _d, _e, block, module_name, version, def, e_1_1, e_2_1;
-        var e_2, _f, e_1, _g;
-        var _h;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
-                case 0:
-                    circuits = {};
-                    _j.label = 1;
-                case 1:
-                    _j.trys.push([1, 12, 13, 14]);
-                    _a = __values(Object.entries(ctx.schematics)), _b = _a.next();
-                    _j.label = 2;
-                case 2:
-                    if (!!_b.done) return [3 /*break*/, 11];
-                    _c = __read(_b.value, 2), v = _c[1];
-                    _j.label = 3;
-                case 3:
-                    _j.trys.push([3, 8, 9, 10]);
-                    _d = (e_1 = void 0, __values((_h = v.blocks) !== null && _h !== void 0 ? _h : [])), _e = _d.next();
-                    _j.label = 4;
-                case 4:
-                    if (!!_e.done) return [3 /*break*/, 7];
-                    block = _e.value;
-                    module_name = fmt_module_name(block.type);
-                    version = ctx.dependencies[module_name];
-                    if (version === undefined) {
-                        console.warn("Module ".concat(module_name, " not found in dependencies"));
-                        return [3 /*break*/, 6];
-                    }
-                    return [4 /*yield*/, ctx.module_resolver.get_module_circuit(__assign(__assign({}, block.type), { version: version }))];
-                case 5:
-                    def = _j.sent();
-                    if (def)
-                        circuits[module_name] = def;
-                    _j.label = 6;
-                case 6:
-                    _e = _d.next();
-                    return [3 /*break*/, 4];
-                case 7: return [3 /*break*/, 10];
-                case 8:
-                    e_1_1 = _j.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 10];
-                case 9:
-                    try {
-                        if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 10:
-                    _b = _a.next();
-                    return [3 /*break*/, 2];
-                case 11: return [3 /*break*/, 14];
-                case 12:
-                    e_2_1 = _j.sent();
-                    e_2 = { error: e_2_1 };
-                    return [3 /*break*/, 14];
-                case 13:
-                    try {
-                        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                    return [7 /*endfinally*/];
-                case 14: return [2 /*return*/, circuits];
-            }
-        });
-    });
+    return circuits;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modular-circuit/perc",
-  "version": "0.0.58",
+  "version": "0.0.59",
   "description": "Programmable Electronic Circuit Check",
   "main": "./build/index.js",
   "files": [
@@ -24,9 +24,9 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@modular-circuit/electronics-model": "0.0.50",
-    "@modular-circuit/ir": "0.0.58",
-    "@modular-circuit/utils": "0.0.36"
+    "@modular-circuit/electronics-model": "0.0.52",
+    "@modular-circuit/utils": "0.0.38",
+    "@modular-circuit/ir": "0.0.59"
   },
   "scripts": {
     "clean": "rimraf build",