playwright-mutation-gate 0.0.1 → 0.2.0

package/dist/lex.js

@@ -0,0 +1,185 @@
+/**
+ * Shared single-pass lexer for the string-based spec analysis. Classifies
+ * every char of a source (a whole file or a single line) so the scanners in
+ * invert.ts and mutate.ts agree about what is code. One implementation on
+ * purpose: two hand-rolled lexers had already diverged once.
+ */
+/** Char inside a string, template literal, block comment or regex literal. */
+export const NON_CODE = 0;
+/** Executable source. */
+export const CODE = 1;
+/** Char of a `//` comment that starts in code context. */
+export const LINE_COMMENT = 2;
+// Keywords after which a `/` starts a regex literal, not division.
+const REGEX_PRECEDING_KEYWORDS = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'do',
+    'else',
+    'case',
+    'yield',
+    'await',
+]);
+const isWordChar = (c) => c !== undefined && /[\w$]/.test(c);
+/**
+ * A `/` in code context is a regex literal when the last significant code
+ * token cannot end an expression: after a value (identifier, `)`, `]`,
+ * string) it is division.
+ */
+function startsRegex(lastSig, lastWord) {
+    if (lastSig === '')
+        return true;
+    if (isWordChar(lastSig))
+        return REGEX_PRECEDING_KEYWORDS.has(lastWord);
+    return lastSig !== ')' && lastSig !== ']' && lastSig !== '"' && lastSig !== "'" && lastSig !== '`';
+}
+/**
+ * Classify every char of `src` as CODE, LINE_COMMENT or NON_CODE. Handles
+ * strings with escapes, template literals with nested `${}` expressions,
+ * `//` and block comments, and regex literals (heuristic: see startsRegex).
+ */
+export function lex(src) {
+    const kind = new Uint8Array(src.length).fill(CODE);
+    // '`' = inside a template literal, '{' = inside a `${}` expression.
+    const stack = [];
+    // Last significant code char, its index, and the word it ends, for regex detection.
+    let lastSig = '';
+    let lastSigIndex = -2;
+    let lastWord = '';
+    let i = 0;
+    while (i < src.length) {
+        const c = src[i];
+        if (stack[stack.length - 1] === '`') {
+            kind[i] = NON_CODE;
+            if (c === '\\') {
+                if (i + 1 < src.length)
+                    kind[i + 1] = NON_CODE;
+                i++;
+            }
+            else if (c === '`') {
+                stack.pop();
+                lastSig = '`';
+                lastWord = '';
+            }
+            else if (c === '$' && src[i + 1] === '{') {
+                kind[i + 1] = NON_CODE;
+                stack.push('{');
+                lastSig = '';
+                lastWord = '';
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            kind[i] = NON_CODE;
+            i++;
+            while (i < src.length && src[i] !== '\n') {
+                kind[i] = NON_CODE;
+                if (src[i] === '\\' && i + 1 < src.length) {
+                    kind[i + 1] = NON_CODE;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (src[i - 1] === c)
+                    break;
+            }
+            lastSig = c;
+            lastWord = '';
+            continue;
+        }
+        if (c === '`') {
+            kind[i] = NON_CODE;
+            stack.push('`');
+            i++;
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '/') {
+            while (i < src.length && src[i] !== '\n')
+                kind[i++] = LINE_COMMENT;
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '*') {
+            kind[i] = NON_CODE;
+            kind[i + 1] = NON_CODE;
+            i += 2;
+            while (i < src.length && !(src[i] === '*' && src[i + 1] === '/'))
+                kind[i++] = NON_CODE;
+            if (i < src.length) {
+                kind[i] = NON_CODE;
+                kind[i + 1] = NON_CODE;
+                i += 2;
+            }
+            continue;
+        }
+        if (c === '/' && startsRegex(lastSig, lastWord)) {
+            kind[i] = NON_CODE;
+            i++;
+            let inClass = false;
+            while (i < src.length && src[i] !== '\n') {
+                kind[i] = NON_CODE;
+                if (src[i] === '\\' && i + 1 < src.length) {
+                    kind[i + 1] = NON_CODE;
+                    i += 2;
+                    continue;
+                }
+                if (src[i] === '[')
+                    inClass = true;
+                else if (src[i] === ']')
+                    inClass = false;
+                else if (src[i] === '/' && !inClass) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            while (i < src.length && /[a-z]/.test(src[i]))
+                kind[i++] = NON_CODE; // flags
+            lastSig = '/';
+            lastWord = '';
+            continue;
+        }
+        if (!/\s/.test(c)) {
+            if (isWordChar(c)) {
+                lastWord = isWordChar(lastSig) && lastSigIndex === i - 1 ? lastWord + c : c;
+            }
+            else {
+                lastWord = '';
+            }
+            lastSig = c;
+            lastSigIndex = i;
+            if (stack.length > 0) {
+                if (c === '{')
+                    stack.push('{');
+                else if (c === '}')
+                    stack.pop();
+            }
+        }
+        i++;
+        continue;
+    }
+    return kind;
+}
+/**
+ * Find the `)` matching the `(` at `open`, counting only CODE chars.
+ * Returns -1 when it does not close within `src`.
+ */
+export function findCloseMasked(src, kind, open) {
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        if (kind[i] !== CODE)
+            continue;
+        if (src[i] === '(')
+            depth++;
+        else if (src[i] === ')' && --depth === 0)
+            return i;
+    }
+    return -1;
+}

package/dist/mutate.d.ts

@@ -0,0 +1,66 @@
+export declare const MARKER = "// @primary-assert";
+export type Mutation = {
+    testTitle: string;
+    /** 1-based line of the test() declaration, for file:line targeting. */
+    testLine: number;
+    /** 1-based line of the `// @primary-assert` marker. */
+    markerLine: number;
+    /** 1-based line of the assertion that was inverted. */
+    assertLine: number;
+    /** Full spec source with exactly this one assertion inverted. */
+    mutatedSource: string;
+} | {
+    testTitle: string;
+    testLine: number;
+    markerLine: number;
+    /** 1-based line of the assertion candidate; null when none was located. */
+    assertLine: number | null;
+    cannotMutate: string;
+};
+export interface PlanOptions {
+    /**
+     * Extra identifiers to treat as test builders, on top of `test` and the
+     * auto-detected `.extend` chains and renamed imports. For custom fixtures
+     * imported by their own name from another module (`import { authedTest }
+     * from './fixtures'`), which cannot be detected without resolving the import.
+     */
+    testIds?: string[];
+}
+export interface SpecPlan {
+    /** One entry per marked test: either a mutated copy or a cannot-mutate reason. */
+    mutations: Mutation[];
+    /** Runnable tests with no marker (sentinel accounting). skip/fixme/fail are exempt. */
+    unmarkedTests: {
+        title: string;
+        line: number;
+    }[];
+    /** 1-based lines of valid markers that sit outside every test() block. */
+    strayMarkerLines: number[];
+    /**
+     * 1-based lines of test.only() declarations. Any .only filters out every
+     * other test in the file, so the runner refuses the whole spec.
+     */
+    onlyTestLines: number[];
+    /** 1-based lines mentioning @primary-assert that do not form a valid marker. */
+    malformedMarkerLines: number[];
+}
+/**
+ * Parse a spec source and plan its mutations: one inverted copy per marked
+ * test. Anything the gate cannot honestly mutate is reported with a reason,
+ * never skipped silently.
+ */
+export declare function planSpecMutations(source: string, opts?: PlanOptions): SpecPlan;
+/**
+ * Name for a mutated copy: the marker segment goes right after the first
+ * dot-segment of the basename, so the ENTIRE original tail is preserved and
+ * the copy matches whatever testMatch convention picked up the original
+ * (`checkout.e2e.ts` -> `checkout.pmg-mutation-0.e2e.ts`).
+ */
+export declare function mutationFilePath(specPath: string, index: number, tag?: string): string;
+/**
+ * Write the mutated copy next to the original spec (same dir keeps relative
+ * imports and the Playwright testDir working) and return its path. The name
+ * carries the process id so overlapping gate runs in one checkout cannot
+ * collide. The caller owns cleanup.
+ */
+export declare function writeMutationFile(specPath: string, index: number, mutatedSource: string): string;

package/dist/mutate.js

@@ -0,0 +1,266 @@
+import { writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { invertAssertLine } from './invert.js';
+import { CODE, LINE_COMMENT, findCloseMasked, lex } from './lex.js';
+export const MARKER = '// @primary-assert';
+/** Read the test title: the first argument when it is a literal without interpolation. */
+function readTitle(src, open) {
+    let i = open + 1;
+    while (i < src.length && /\s/.test(src[i]))
+        i++;
+    const quote = src[i];
+    if (quote !== "'" && quote !== '"' && quote !== '`')
+        return '(dynamic title)';
+    let title = '';
+    for (i++; i < src.length; i++) {
+        const c = src[i];
+        if (c === '\\' && i + 1 < src.length) {
+            title += src[i + 1];
+            i++;
+        }
+        else if (quote === '`' && c === '$' && src[i + 1] === '{') {
+            return '(dynamic title)';
+        }
+        else if (c === quote) {
+            return title;
+        }
+        else {
+            title += c;
+        }
+    }
+    return title;
+}
+const IDENT = '[A-Za-z_$][\\w$]*';
+/** True when the first argument at `open` (the call's `(`) is a string literal. */
+function firstArgIsStringLiteral(src, open) {
+    let i = open + 1;
+    while (i < src.length && /\s/.test(src[i]))
+        i++;
+    const c = src[i];
+    return c === "'" || c === '"' || c === '`';
+}
+/**
+ * The set of identifiers that declare a test in this file. Always `test`, plus
+ * any passed in explicitly (`--test-id`), plus auto-detected custom fixtures:
+ * a local `const X = <known>.extend(...)` chain, or a renamed import
+ * (`import { test as X }`). Resolved to a fixpoint so chained extends and
+ * renames of just-discovered ids are picked up too.
+ */
+function collectTestIds(src, kind, extra) {
+    const ids = new Set(['test', ...extra]);
+    const renameRe = new RegExp(`\\b(${IDENT})\\s+as\\s+(${IDENT})`, 'g');
+    const extendRe = new RegExp(`\\b(?:const|let|var)\\s+(${IDENT})\\s*=\\s*(${IDENT})\\s*\\.\\s*extend\\s*\\(`, 'g');
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const m of src.matchAll(renameRe)) {
+            if (kind[m.index] !== CODE)
+                continue;
+            if (ids.has(m[1]) && !ids.has(m[2])) {
+                ids.add(m[2]);
+                changed = true;
+            }
+        }
+        for (const m of src.matchAll(extendRe)) {
+            if (kind[m.index] !== CODE)
+                continue;
+            if (ids.has(m[2]) && !ids.has(m[1])) {
+                ids.add(m[1]);
+                changed = true;
+            }
+        }
+    }
+    return ids;
+}
+function findTestBlocks(src, kind, ids) {
+    const alt = [...ids].sort((a, b) => b.length - a.length).join('|');
+    const anchor = new RegExp(`\\b(?:${alt})\\s*(?:\\.\\s*(only|skip|fixme|fail)\\s*)?\\(`, 'g');
+    const blocks = [];
+    for (const m of src.matchAll(anchor)) {
+        if (kind[m.index] !== CODE)
+            continue;
+        // Excludes member calls like `t.test(...)`; `test.describe(` and
+        // `test.step(` never match the regex in the first place.
+        if (m.index > 0 && src[m.index - 1] === '.')
+            continue;
+        const mode = (m[1] ?? '');
+        const open = m.index + m[0].length - 1;
+        // `test.skip('title', fn)` declares a skipped test; `test.skip(!cond)` is a
+        // runtime modifier statement inside a test body. Only the declaration form
+        // (string title) is a block; the modifier is left to sit inside its test.
+        if (UNGATEABLE_MODES.has(mode) && !firstArgIsStringLiteral(src, open))
+            continue;
+        const close = findCloseMasked(src, kind, open);
+        blocks.push({
+            title: readTitle(src, open),
+            mode,
+            anchor: m.index,
+            open,
+            close: close === -1 ? src.length : close,
+            markers: [],
+        });
+    }
+    return blocks;
+}
+// test.skip/fixme never run and test.fail inverts pass/fail semantics, so a
+// mutation verdict on them would be a lie; they are also exempt from sentinel
+// accounting. test.only runs and is treated like a plain test.
+const UNGATEABLE_MODES = new Set(['skip', 'fixme', 'fail']);
+/**
+ * Parse a spec source and plan its mutations: one inverted copy per marked
+ * test. Anything the gate cannot honestly mutate is reported with a reason,
+ * never skipped silently.
+ */
+export function planSpecMutations(source, opts = {}) {
+    const kind = lex(source);
+    const ids = collectTestIds(source, kind, opts.testIds ?? []);
+    const blocks = findTestBlocks(source, kind, ids);
+    const lines = source.split('\n');
+    // Char offset of each line start, to map offsets to 1-based line numbers.
+    const starts = [0];
+    for (let i = 0; i < source.length; i++)
+        if (source[i] === '\n')
+            starts.push(i + 1);
+    const lineOf = (offset) => {
+        let n = 0;
+        while (n + 1 < starts.length && starts[n + 1] <= offset)
+            n++;
+        return n + 1;
+    };
+    // A line "has code" when any of its chars is CODE and not whitespace;
+    // blank, comment-only and string-interior lines do not.
+    const lineHasCode = (n) => {
+        for (let j = starts[n], end = starts[n] + lines[n].length; j < end; j++) {
+            if (kind[j] === CODE && !/\s/.test(source[j]))
+                return true;
+        }
+        return false;
+    };
+    // The `//` line comment on a line (in code context), or null when the line
+    // has none. `codeBefore` distinguishes a trailing marker (assertion code
+    // precedes the comment) from a whole-line one.
+    const lineComment = (n) => {
+        const start = starts[n];
+        const end = start + lines[n].length;
+        let c = -1;
+        for (let j = start; j < end; j++) {
+            if (kind[j] === LINE_COMMENT) {
+                c = j;
+                break;
+            }
+        }
+        if (c === -1)
+            return null;
+        let codeBefore = false;
+        for (let j = start; j < c; j++) {
+            if (kind[j] === CODE && !/\s/.test(source[j])) {
+                codeBefore = true;
+                break;
+            }
+        }
+        return { codeBefore, text: source.slice(c, end).trim() };
+    };
+    const strayMarkerLines = [];
+    const malformedMarkerLines = [];
+    for (let n = 0; n < lines.length; n++) {
+        const line = lines[n];
+        if (!line.includes('@primary-assert'))
+            continue;
+        // A valid marker is a `// @primary-assert` line comment in code context,
+        // either on its own line (assertion is the next code line) or trailing the
+        // assertion. The same text inside a block comment, string, template, or as
+        // a near-miss (`// @primary-assert: foo`) is not a marker.
+        const lc = lineComment(n);
+        if (!lc || lc.text !== MARKER) {
+            malformedMarkerLines.push(n + 1);
+            continue;
+        }
+        const firstNonWs = starts[n] + (line.length - line.trimStart().length);
+        const block = blocks.find((b) => firstNonWs > b.open && firstNonWs < b.close);
+        if (block)
+            block.markers.push({ line: n + 1, sameLine: lc.codeBefore });
+        else
+            strayMarkerLines.push(n + 1);
+    }
+    const mutations = [];
+    const unmarkedTests = [];
+    const onlyTestLines = [];
+    for (const block of blocks) {
+        const testLine = lineOf(block.anchor);
+        if (block.mode === 'only')
+            onlyTestLines.push(testLine);
+        if (block.markers.length === 0) {
+            if (!UNGATEABLE_MODES.has(block.mode)) {
+                unmarkedTests.push({ title: block.title, line: testLine });
+            }
+            continue;
+        }
+        const marker = block.markers[0];
+        const base = { testTitle: block.title, testLine, markerLine: marker.line };
+        if (UNGATEABLE_MODES.has(block.mode)) {
+            const why = block.mode === 'fail'
+                ? 'test.fail() expects failure, so a mutation verdict would be meaningless'
+                : `test.${block.mode}() never runs, so a mutation cannot be observed`;
+            mutations.push({ ...base, assertLine: null, cannotMutate: why });
+            continue;
+        }
+        if (block.markers.length > 1) {
+            mutations.push({
+                ...base,
+                assertLine: null,
+                cannotMutate: `found ${block.markers.length} @primary-assert markers in one test, expected exactly one`,
+            });
+            continue;
+        }
+        // A trailing marker sits on the assertion itself; a whole-line marker
+        // points at the next line that contains code (blank and comment-only lines
+        // are skipped, not mutated).
+        let target; // 0-based index of the assertion line
+        if (marker.sameLine) {
+            target = marker.line - 1;
+        }
+        else {
+            target = marker.line; // 0-based index of the line after the marker
+            while (target < lines.length && !lineHasCode(target))
+                target++;
+            if (target >= lines.length) {
+                mutations.push({ ...base, assertLine: null, cannotMutate: 'no code line follows the marker' });
+                continue;
+            }
+        }
+        const inverted = invertAssertLine(lines[target]);
+        if ('cannotMutate' in inverted) {
+            mutations.push({ ...base, assertLine: target + 1, cannotMutate: inverted.cannotMutate });
+            continue;
+        }
+        const mutatedLines = lines.slice();
+        mutatedLines[target] = inverted.ok;
+        mutations.push({ ...base, assertLine: target + 1, mutatedSource: mutatedLines.join('\n') });
+    }
+    return { mutations, unmarkedTests, strayMarkerLines, malformedMarkerLines, onlyTestLines };
+}
+/**
+ * Name for a mutated copy: the marker segment goes right after the first
+ * dot-segment of the basename, so the ENTIRE original tail is preserved and
+ * the copy matches whatever testMatch convention picked up the original
+ * (`checkout.e2e.ts` -> `checkout.pmg-mutation-0.e2e.ts`).
+ */
+export function mutationFilePath(specPath, index, tag = '') {
+    const base = basename(specPath);
+    const dot = base.indexOf('.', 1); // a leading dot (dotfile) stays with the stem
+    const stem = dot === -1 ? base : base.slice(0, dot);
+    const tail = dot === -1 ? '' : base.slice(dot);
+    const marker = tag === '' ? `pmg-mutation-${index}` : `pmg-mutation-${index}-${tag}`;
+    return join(dirname(specPath), `${stem}.${marker}${tail}`);
+}
+/**
+ * Write the mutated copy next to the original spec (same dir keeps relative
+ * imports and the Playwright testDir working) and return its path. The name
+ * carries the process id so overlapping gate runs in one checkout cannot
+ * collide. The caller owns cleanup.
+ */
+export function writeMutationFile(specPath, index, mutatedSource) {
+    const path = mutationFilePath(specPath, index, process.pid.toString(36));
+    writeFileSync(path, mutatedSource);
+    return path;
+}

package/dist/report.d.ts

@@ -0,0 +1,31 @@
+import type { SpecResult } from './run.js';
+export interface GateOptions {
+    /** When true (default), tests without a @primary-assert marker fail the gate. */
+    requireSentinel: boolean;
+}
+export interface Summary {
+    killed: number;
+    survived: number;
+    cannotMutate: number;
+    errors: number;
+    unmarkedTests: number;
+    strayMarkers: number;
+    malformedMarkers: number;
+    /**
+     * Green means proven: every marked assertion was killed under inversion and
+     * nothing was left unverified. Any survived, cannot-mutate or error verdict
+     * fails the gate, as do marker mistakes (stray or malformed markers) and,
+     * under require-sentinel, tests with no marker at all.
+     */
+    gatePassed: boolean;
+}
+export declare function summarize(specs: SpecResult[], opts: GateOptions): Summary;
+export declare function jsonReport(specs: SpecResult[], opts: GateOptions): string;
+export interface RenderOptions extends GateOptions {
+    color: boolean;
+}
+/**
+ * Human-readable report: per spec, one row per verdict plus sentinel findings,
+ * then a one-line summary and the gate outcome.
+ */
+export declare function renderTable(specs: SpecResult[], opts: RenderOptions): string;

package/dist/report.js

@@ -0,0 +1,99 @@
+export function summarize(specs, opts) {
+    const s = {
+        killed: 0,
+        survived: 0,
+        cannotMutate: 0,
+        errors: 0,
+        unmarkedTests: 0,
+        strayMarkers: 0,
+        malformedMarkers: 0,
+        gatePassed: true,
+    };
+    for (const spec of specs) {
+        for (const m of spec.results) {
+            if (m.verdict === 'killed')
+                s.killed++;
+            else if (m.verdict === 'survived')
+                s.survived++;
+            else if (m.verdict === 'cannot-mutate')
+                s.cannotMutate++;
+            else
+                s.errors++;
+        }
+        s.unmarkedTests += spec.unmarkedTests.length;
+        s.strayMarkers += spec.strayMarkerLines.length;
+        s.malformedMarkers += spec.malformedMarkerLines.length;
+    }
+    s.gatePassed =
+        s.survived === 0 &&
+            s.cannotMutate === 0 &&
+            s.errors === 0 &&
+            s.strayMarkers === 0 &&
+            s.malformedMarkers === 0 &&
+            (!opts.requireSentinel || s.unmarkedTests === 0);
+    return s;
+}
+export function jsonReport(specs, opts) {
+    return JSON.stringify({ specs, summary: summarize(specs, opts) }, null, 2);
+}
+const RESET = '\x1b[0m';
+const VERDICT_COLOR = {
+    killed: '\x1b[32m',
+    survived: '\x1b[31m',
+    'cannot-mutate': '\x1b[33m',
+    error: '\x1b[33m',
+};
+const TITLE_WIDTH = 48;
+function clip(title) {
+    return title.length <= TITLE_WIDTH ? title : title.slice(0, TITLE_WIDTH - 3) + '...';
+}
+/**
+ * Human-readable report: per spec, one row per verdict plus sentinel findings,
+ * then a one-line summary and the gate outcome.
+ */
+export function renderTable(specs, opts) {
+    const paint = (color, text) => opts.color ? color + text + RESET : text;
+    const labelWidth = 'cannot-mutate'.length;
+    const titleWidth = Math.min(TITLE_WIDTH, Math.max(4, ...specs.flatMap((spec) => [
+        ...spec.results.map((m) => clip(m.testTitle).length),
+        ...spec.unmarkedTests.map((t) => clip(t.title).length),
+    ])));
+    const row = (label, color, title, line) => '  ' + paint(color, label.padEnd(labelWidth)) + '  ' + clip(title).padEnd(titleWidth) + '  ' + line;
+    const lines = [];
+    for (const spec of specs) {
+        lines.push(spec.specPath);
+        for (const m of spec.results) {
+            const at = m.assertLine === null ? ':?' : `:${m.assertLine}`;
+            lines.push(row(m.verdict, VERDICT_COLOR[m.verdict], m.testTitle, at));
+            if (m.reason !== undefined) {
+                lines.push('  ' + ' '.repeat(labelWidth) + '  ' + m.reason);
+            }
+        }
+        for (const t of spec.unmarkedTests) {
+            lines.push(row('unmarked', VERDICT_COLOR['cannot-mutate'], t.title, `:${t.line}`));
+        }
+        for (const line of spec.strayMarkerLines) {
+            lines.push(`  marker outside any test() block at line ${line}`);
+        }
+        for (const line of spec.malformedMarkerLines) {
+            lines.push(`  malformed @primary-assert marker at line ${line}`);
+        }
+        lines.push('');
+    }
+    const s = summarize(specs, opts);
+    const counts = [
+        `${s.killed} killed`,
+        `${s.survived} survived`,
+        `${s.cannotMutate} cannot-mutate`,
+        `${s.errors} errors`,
+    ];
+    if (s.unmarkedTests > 0) {
+        counts.push(`${s.unmarkedTests} unmarked ${s.unmarkedTests === 1 ? 'test' : 'tests'}` +
+            (opts.requireSentinel ? '' : ' (not enforced)'));
+    }
+    lines.push(counts.join(', '));
+    lines.push(s.gatePassed
+        ? paint('\x1b[1;32m', 'Gate passed: every marked assertion can fail.')
+        : paint('\x1b[1;31m', 'Gate FAILED: hollow, unverified or broken assertions above.'));
+    return lines.join('\n');
+}