@primmel/primmel 1.3.2 → 1.4.0

package/dist/src/ser-des/config/design.js

@@ -0,0 +1,847 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────────────
+// Test-design block parser + dumper (conformance_test `design { … }`).
+//
+// Maps data/schemas/cc.yaml $defs/testDesign (TODO.refactor/09):
+//
+//   design {
+//     counts {
+//       count field_automatic {
+//         min 500
+//         clause "4.4"
+//         override { condition statistical_analysis by evaluator note "..." }
+//       }
+//     }
+//     severities {
+//       severity "1 dry heat (operating)" {
+//         criterion I/MPE
+//         footnotes { a b }
+//         env climatic_environment_class { level 2 }
+//         env mechanical_environment_class null
+//         env electromagnetic_environment_class {
+//           amplitude 10
+//           unit "V/m"
+//           variable field_strength
+//           columns {
+//             ac { amplitude 10 unit "V/m" }
+//             dc null
+//             vehicle_dc { amplitude 10 unit "V" note "..." }
+//           }
+//         }
+//       }
+//     }
+//     test_points { ref r144-cgm-points }
+//     schedule {
+//       duration P7D
+//       cadence PT24H
+//       phases { phase soak { condition "..." window PT2H } }
+//       constraints { "apply D_max and hold" }
+//     }
+//     specimens {
+//       count 1
+//       max_additional 2
+//       selection "ocl{...}"
+//       continuity same_eut
+//       rules { unit-continuity }
+//     }
+//   }
+// ─────────────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDesign = parseDesign;
+exports.dumpDesign = dumpDesign;
+const tokenize_1 = require("../tokenize");
+const tokenize_2 = require("../tokenize");
+const field_parser_1 = require("./field-parser");
+function readQuotedList(block) {
+    return (0, tokenize_1.default)((0, tokenize_2.stripWrapping)(block))
+        .map(tokenize_2.stripWrapping)
+        .filter(s => s.length > 0);
+}
+function parseSeverityCell(block) {
+    const cell = {
+        level: null,
+        code: '',
+        amplitude: null,
+        unit: '',
+        note: '',
+        variable: '',
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'level') {
+            cell.level = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'code') {
+            cell.code = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'amplitude') {
+            cell.amplitude = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'unit') {
+            cell.unit = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'note') {
+            cell.note = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'variable') {
+            cell.variable = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return cell;
+}
+function parseSeverityValue(block) {
+    const value = {
+        level: null,
+        code: '',
+        amplitude: null,
+        unit: '',
+        note: '',
+        variable: '',
+        columns: null,
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'level') {
+            value.level = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'code') {
+            value.code = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'amplitude') {
+            value.amplitude = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'unit') {
+            value.unit = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'note') {
+            value.note = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'variable') {
+            value.variable = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'columns') {
+            const ct = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            const columns = {
+                ac: null,
+                dc: null,
+                vehicleDc: null,
+            };
+            let j = 0;
+            while (j < ct.length) {
+                const col = (0, field_parser_1.stripColon)(ct[j++]);
+                if (j >= ct.length) {
+                    break;
+                }
+                const tok = ct[j++];
+                const cell = tok.startsWith('{')
+                    ? parseSeverityCell((0, tokenize_2.unwrapBlock)(tok))
+                    : null;
+                if (col === 'ac') {
+                    columns.ac = cell;
+                }
+                else if (col === 'dc') {
+                    columns.dc = cell;
+                }
+                else if (col === 'vehicle_dc') {
+                    columns.vehicleDc = cell;
+                }
+            }
+            value.columns = columns;
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return value;
+}
+function parseCounts(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'count') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const count = {
+            context: (0, tokenize_2.stripWrapping)(t[i++]),
+            minCount: 0,
+            clause: '',
+            note: '',
+            override: null,
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const ct = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < ct.length) {
+                const cc = ct[j++];
+                if (j >= ct.length) {
+                    break;
+                }
+                if (cc === 'min') {
+                    count.minCount = Number((0, tokenize_2.stripWrapping)(ct[j++]));
+                }
+                else if (cc === 'clause') {
+                    count.clause = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'note') {
+                    count.note = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'override') {
+                    const ot = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(ct[j++]));
+                    const override = { condition: '', by: '', note: '' };
+                    let k = 0;
+                    while (k < ot.length) {
+                        const oc = ot[k++];
+                        if (k >= ot.length) {
+                            break;
+                        }
+                        if (oc === 'condition') {
+                            override.condition = (0, tokenize_2.stripWrapping)(ot[k++]);
+                        }
+                        else if (oc === 'by') {
+                            override.by = (0, tokenize_2.stripWrapping)(ot[k++]);
+                        }
+                        else if (oc === 'note') {
+                            override.note = (0, tokenize_2.stripWrapping)(ot[k++]);
+                        }
+                        else {
+                            (0, tokenize_2.unwrapBlock)(ot[k++]);
+                        }
+                    }
+                    count.override = override;
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(ct[j++]);
+                }
+            }
+        }
+        out.push(count);
+    }
+    return out;
+}
+function parseSeverities(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'severity') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const severity = {
+            row: (0, tokenize_2.stripWrapping)(t[i++]),
+            envClassValues: {},
+            criterion: '',
+            footnotes: [],
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const st = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < st.length) {
+                const sc = st[j++];
+                if (j >= st.length) {
+                    break;
+                }
+                if (sc === 'criterion') {
+                    severity.criterion = (0, tokenize_2.stripWrapping)(st[j++]);
+                }
+                else if (sc === 'footnotes') {
+                    severity.footnotes = readQuotedList(st[j++]);
+                }
+                else if (sc === 'env') {
+                    const classId = (0, tokenize_2.stripWrapping)(st[j++]);
+                    const tok = st[j++] ?? '';
+                    severity.envClassValues[classId] = tok.startsWith('{')
+                        ? parseSeverityValue((0, tokenize_2.unwrapBlock)(tok))
+                        : null;
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(st[j++]);
+                }
+            }
+        }
+        out.push(severity);
+    }
+    return out;
+}
+function parseSchedule(block) {
+    const schedule = {
+        duration: '',
+        cadence: '',
+        phases: [],
+        constraints: [],
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'duration') {
+            schedule.duration = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'cadence') {
+            schedule.cadence = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'phases') {
+            const pt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < pt.length) {
+                const pc = pt[j++];
+                if (pc !== 'phase') {
+                    if (j < pt.length) {
+                        (0, tokenize_2.unwrapBlock)(pt[j - 1]);
+                    }
+                    continue;
+                }
+                const phase = {
+                    id: (0, tokenize_2.stripWrapping)(pt[j++]),
+                    condition: '',
+                    window: '',
+                };
+                if (j < pt.length && pt[j].startsWith('{')) {
+                    const ht = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(pt[j++]));
+                    let k = 0;
+                    while (k < ht.length) {
+                        const hc = ht[k++];
+                        if (k >= ht.length) {
+                            break;
+                        }
+                        if (hc === 'condition') {
+                            phase.condition = (0, tokenize_2.stripWrapping)(ht[k++]);
+                        }
+                        else if (hc === 'window') {
+                            phase.window = (0, tokenize_2.stripWrapping)(ht[k++]);
+                        }
+                        else {
+                            (0, tokenize_2.unwrapBlock)(ht[k++]);
+                        }
+                    }
+                }
+                schedule.phases.push(phase);
+            }
+        }
+        else if (cmd === 'constraints') {
+            schedule.constraints = readQuotedList(t[i++]);
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return schedule;
+}
+function parseSpecimens(block) {
+    const specimens = {
+        count: null,
+        maxAdditional: null,
+        selection: '',
+        selectionRef: '',
+        continuity: '',
+        rules: [],
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'count') {
+            specimens.count = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'max_additional') {
+            specimens.maxAdditional = Number((0, tokenize_2.stripWrapping)(t[i++]));
+        }
+        else if (cmd === 'selection') {
+            const tok = t[i++];
+            if (tok.startsWith('{')) {
+                // selection { ref <rule-id> } — sample-selection rule reference.
+                const st = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(tok));
+                let j = 0;
+                while (j < st.length) {
+                    const sc = st[j++];
+                    if (j >= st.length) {
+                        break;
+                    }
+                    if (sc === 'ref') {
+                        specimens.selectionRef = (0, tokenize_2.stripWrapping)(st[j++]);
+                    }
+                    else {
+                        (0, tokenize_2.unwrapBlock)(st[j++]);
+                    }
+                }
+            }
+            else {
+                specimens.selection = (0, tokenize_2.stripWrapping)(tok);
+            }
+        }
+        else if (cmd === 'continuity') {
+            specimens.continuity = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'rules') {
+            specimens.rules = readQuotedList(t[i++]);
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return specimens;
+}
+/** Parse the content of a `design { … }` block. */
+function parseDesign(block) {
+    const design = {
+        counts: [],
+        severities: [],
+        testPointsRef: '',
+        schedule: null,
+        specimens: null,
+        field: null,
+        simulation: null,
+        software: null,
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'counts') {
+            design.counts = parseCounts((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'severities') {
+            design.severities = parseSeverities((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'test_points') {
+            const pt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < pt.length) {
+                const pc = pt[j++];
+                if (j >= pt.length) {
+                    break;
+                }
+                if (pc === 'ref') {
+                    design.testPointsRef = (0, tokenize_2.stripWrapping)(pt[j++]);
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(pt[j++]);
+                }
+            }
+        }
+        else if (cmd === 'schedule') {
+            design.schedule = parseSchedule((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'specimens') {
+            design.specimens = parseSpecimens((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'field') {
+            design.field = parseField((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'simulation') {
+            design.simulation = parseSimulation((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'software') {
+            design.software = parseSoftware((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return design;
+}
+/** kind: field — site_selection / traffic_conditions / reference_meter. */
+function parseField(block) {
+    const field = {
+        siteSelection: '',
+        trafficConditions: '',
+        referenceMeter: null,
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'site_selection') {
+            field.siteSelection = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'traffic_conditions') {
+            field.trafficConditions = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'reference_meter') {
+            const rm = { description: '', uncertaintyBudget: '' };
+            const rt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < rt.length) {
+                const rc = rt[j++];
+                if (j >= rt.length) {
+                    break;
+                }
+                if (rc === 'description') {
+                    rm.description = (0, tokenize_2.stripWrapping)(rt[j++]);
+                }
+                else if (rc === 'uncertainty_budget') {
+                    rm.uncertaintyBudget = (0, tokenize_2.stripWrapping)(rt[j++]);
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(rt[j++]);
+                }
+            }
+            field.referenceMeter = rm;
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return field;
+}
+/** kind: simulation — simulator_kind / signal / uncertainty_budget / validation. */
+function parseSimulation(block) {
+    const sim = {
+        simulatorKind: '',
+        signal: '',
+        uncertaintyBudget: '',
+        validation: '',
+    };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'simulator_kind') {
+            sim.simulatorKind = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'signal') {
+            sim.signal = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'uncertainty_budget') {
+            sim.uncertaintyBudget = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'validation') {
+            sim.validation = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return sim;
+}
+/** kind: software-examination — level + the D 31 item matrix. */
+function parseSoftware(block) {
+    const software = { level: '', items: [] };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'level') {
+            software.level = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'items') {
+            const it = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < it.length) {
+                const ic = it[j++];
+                if (ic !== 'item') {
+                    if (j < it.length) {
+                        (0, tokenize_2.unwrapBlock)(it[j - 1]);
+                    }
+                    continue;
+                }
+                const item = {
+                    item: Number((0, tokenize_2.stripWrapping)(it[j++])),
+                    name: '',
+                    d31: '',
+                    obligation: '',
+                    methods: [],
+                    clause: '',
+                };
+                if (j < it.length && it[j].startsWith('{')) {
+                    const bt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(it[j++]));
+                    let k = 0;
+                    while (k < bt.length) {
+                        const bc = bt[k++];
+                        if (k >= bt.length) {
+                            break;
+                        }
+                        if (bc === 'name') {
+                            item.name = (0, tokenize_2.stripWrapping)(bt[k++]);
+                        }
+                        else if (bc === 'd31') {
+                            item.d31 = (0, tokenize_2.stripWrapping)(bt[k++]);
+                        }
+                        else if (bc === 'obligation') {
+                            item.obligation = (0, tokenize_2.stripWrapping)(bt[k++]);
+                        }
+                        else if (bc === 'methods') {
+                            item.methods = readQuotedList(bt[k++]);
+                        }
+                        else if (bc === 'clause') {
+                            item.clause = (0, tokenize_2.stripWrapping)(bt[k++]);
+                        }
+                        else {
+                            (0, tokenize_2.unwrapBlock)(bt[k++]);
+                        }
+                    }
+                }
+                software.items.push(item);
+            }
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return software;
+}
+function dumpCell(cell) {
+    let out = '';
+    if (cell.level !== null) {
+        out += 'level ' + cell.level + ' ';
+    }
+    if (cell.code) {
+        out += 'code "' + (0, tokenize_2.escapeString)(cell.code) + '" ';
+    }
+    if (cell.amplitude !== null) {
+        out += 'amplitude ' + cell.amplitude + ' ';
+    }
+    if (cell.unit) {
+        out += 'unit "' + (0, tokenize_2.escapeString)(cell.unit) + '" ';
+    }
+    if (cell.note) {
+        out += 'note "' + (0, tokenize_2.escapeString)(cell.note) + '" ';
+    }
+    if (cell.variable) {
+        out += 'variable ' + cell.variable + ' ';
+    }
+    return out;
+}
+function dumpSeverityValue(value) {
+    let out = dumpCell(value);
+    if (value.columns) {
+        out += 'columns { ';
+        out += value.columns.ac
+            ? 'ac { ' + dumpCell(value.columns.ac) + '} '
+            : 'ac null ';
+        out += value.columns.dc
+            ? 'dc { ' + dumpCell(value.columns.dc) + '} '
+            : 'dc null ';
+        out += value.columns.vehicleDc
+            ? 'vehicle_dc { ' + dumpCell(value.columns.vehicleDc) + '} '
+            : 'vehicle_dc null ';
+        out += '} ';
+    }
+    return out;
+}
+/**
+ * Dump a test design as a multi-line `design { … }` block (with
+ * trailing newline) at the given indent.
+ */
+function dumpDesign(design, indent) {
+    let out = indent + 'design {\n';
+    if (design.counts.length > 0) {
+        out += indent + '  counts {\n';
+        for (const c of design.counts) {
+            let line = indent + '    count ' + c.context + ' { min ' + c.minCount + ' ';
+            if (c.clause) {
+                line += 'clause "' + (0, tokenize_2.escapeString)(c.clause) + '" ';
+            }
+            if (c.note) {
+                line += 'note "' + (0, tokenize_2.escapeString)(c.note) + '" ';
+            }
+            if (c.override) {
+                line += 'override { condition ' + c.override.condition;
+                line += ' by ' + c.override.by;
+                if (c.override.note) {
+                    line += ' note "' + (0, tokenize_2.escapeString)(c.override.note) + '"';
+                }
+                line += ' } ';
+            }
+            out += line + '}\n';
+        }
+        out += indent + '  }\n';
+    }
+    if (design.severities.length > 0) {
+        out += indent + '  severities {\n';
+        for (const s of design.severities) {
+            let line = indent + '    severity "' + (0, tokenize_2.escapeString)(s.row) + '" { ';
+            if (s.criterion) {
+                line += 'criterion ' + s.criterion + ' ';
+            }
+            if (s.footnotes.length > 0) {
+                line += 'footnotes { ' + s.footnotes.join(' ') + ' } ';
+            }
+            for (const [classId, value] of Object.entries(s.envClassValues)) {
+                line +=
+                    'env ' +
+                        classId +
+                        ' ' +
+                        (value ? '{ ' + dumpSeverityValue(value) + '}' : 'null') +
+                        ' ';
+            }
+            out += line + '}\n';
+        }
+        out += indent + '  }\n';
+    }
+    if (design.testPointsRef) {
+        out += indent + '  test_points { ref ' + design.testPointsRef + ' }\n';
+    }
+    if (design.schedule) {
+        const s = design.schedule;
+        let line = indent + '  schedule { ';
+        if (s.duration) {
+            line += 'duration ' + s.duration + ' ';
+        }
+        if (s.cadence) {
+            line += 'cadence ' + s.cadence + ' ';
+        }
+        if (s.phases.length > 0) {
+            line += 'phases { ';
+            for (const p of s.phases) {
+                line += 'phase ' + p.id + ' { ';
+                if (p.condition) {
+                    line += 'condition "' + (0, tokenize_2.escapeString)(p.condition) + '" ';
+                }
+                if (p.window) {
+                    line += 'window ' + p.window + ' ';
+                }
+                line += '} ';
+            }
+            line += '} ';
+        }
+        if (s.constraints.length > 0) {
+            line +=
+                'constraints { ' +
+                    s.constraints.map(c => '"' + (0, tokenize_2.escapeString)(c) + '"').join(' ') +
+                    ' } ';
+        }
+        out += line + '}\n';
+    }
+    if (design.specimens) {
+        const s = design.specimens;
+        let line = indent + '  specimens { ';
+        if (s.count !== null) {
+            line += 'count ' + s.count + ' ';
+        }
+        if (s.maxAdditional !== null) {
+            line += 'max_additional ' + s.maxAdditional + ' ';
+        }
+        if (s.selectionRef) {
+            line += 'selection { ref ' + s.selectionRef + ' } ';
+        }
+        else if (s.selection) {
+            line += 'selection "' + (0, tokenize_2.escapeString)(s.selection) + '" ';
+        }
+        if (s.continuity) {
+            line += 'continuity ' + s.continuity + ' ';
+        }
+        if (s.rules.length > 0) {
+            line += 'rules { ' + s.rules.join(' ') + ' } ';
+        }
+        out += line + '}\n';
+    }
+    if (design.field) {
+        const f = design.field;
+        out += indent + '  field {\n';
+        if (f.siteSelection) {
+            out +=
+                indent + '    site_selection "' + (0, tokenize_2.escapeString)(f.siteSelection) + '"\n';
+        }
+        if (f.trafficConditions) {
+            out +=
+                indent +
+                    '    traffic_conditions "' +
+                    (0, tokenize_2.escapeString)(f.trafficConditions) +
+                    '"\n';
+        }
+        if (f.referenceMeter) {
+            let line = indent + '    reference_meter { ';
+            if (f.referenceMeter.description) {
+                line +=
+                    'description "' + (0, tokenize_2.escapeString)(f.referenceMeter.description) + '" ';
+            }
+            if (f.referenceMeter.uncertaintyBudget) {
+                line +=
+                    'uncertainty_budget ' + f.referenceMeter.uncertaintyBudget + ' ';
+            }
+            out += line + '}\n';
+        }
+        out += indent + '  }\n';
+    }
+    if (design.simulation) {
+        const s = design.simulation;
+        out += indent + '  simulation {\n';
+        if (s.simulatorKind) {
+            out += indent + '    simulator_kind ' + s.simulatorKind + '\n';
+        }
+        if (s.signal) {
+            out += indent + '    signal "' + (0, tokenize_2.escapeString)(s.signal) + '"\n';
+        }
+        if (s.uncertaintyBudget) {
+            out += indent + '    uncertainty_budget ' + s.uncertaintyBudget + '\n';
+        }
+        if (s.validation) {
+            out += indent + '    validation "' + (0, tokenize_2.escapeString)(s.validation) + '"\n';
+        }
+        out += indent + '  }\n';
+    }
+    if (design.software) {
+        const s = design.software;
+        out += indent + '  software {\n';
+        if (s.level) {
+            out += indent + '    level ' + s.level + '\n';
+        }
+        if (s.items.length > 0) {
+            out += indent + '    items {\n';
+            for (const it of s.items) {
+                let line = indent + '      item ' + it.item + ' { ';
+                if (it.name) {
+                    line += 'name "' + (0, tokenize_2.escapeString)(it.name) + '" ';
+                }
+                if (it.d31) {
+                    line += 'd31 "' + (0, tokenize_2.escapeString)(it.d31) + '" ';
+                }
+                if (it.obligation) {
+                    line += 'obligation ' + it.obligation + ' ';
+                }
+                if (it.methods.length > 0) {
+                    line += 'methods { ' + it.methods.join(' ') + ' } ';
+                }
+                if (it.clause) {
+                    line += 'clause "' + (0, tokenize_2.escapeString)(it.clause) + '" ';
+                }
+                out += line + '}\n';
+            }
+            out += indent + '    }\n';
+        }
+        out += indent + '  }\n';
+    }
+    out += indent + '}\n';
+    return out;
+}
+//# sourceMappingURL=design.js.map