cloving 1.1.0 → 1.3.0

package/dist/tools/workflow-bundles.js

@@ -0,0 +1,173 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const unavailable = {
+    kind: "unavailable",
+    code: "pinned-workflow-unavailable",
+};
+export async function readRetainedWorkflowBundle(input) {
+    if (!/^[a-f0-9]{64}$/.test(input.id))
+        return unavailable;
+    try {
+        const directory = join(input.directory, input.id);
+        if (!(await lstat(directory)).isDirectory())
+            return unavailable;
+        const repository = await realpath(input.repository);
+        const contents = bundleContents(repository, await projectFiles(directory));
+        const stored = await regularFile(join(directory, "bundle.json"));
+        if (digest(contents) !== input.id || stored.toString("utf8") !== contents)
+            return unavailable;
+        return { kind: "available", directory };
+    }
+    catch {
+        return unavailable;
+    }
+}
+function digest(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+async function regularFile(path) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        if (!(await file.stat()).isFile())
+            throw new Error("invalid-bundle-file");
+        return await file.readFile();
+    }
+    finally {
+        await file.close();
+    }
+}
+async function treeFiles(root, name) {
+    const path = join(root, name);
+    const entry = await lstat(path);
+    if (entry.isFile())
+        return [{ name, bytes: await regularFile(path) }];
+    if (!entry.isDirectory())
+        throw new Error("invalid-bundle-file");
+    const files = [];
+    for (const child of (await readdir(path)).sort())
+        files.push(...(await treeFiles(root, `${name}/${child}`)));
+    return files;
+}
+async function projectFiles(project) {
+    const files = [];
+    const names = (await readdir(project)).filter((name) => name.endsWith(".json") && name !== "bundle.json");
+    for (const name of [...names, "artifacts", "workflows"].sort())
+        files.push(...(await treeFiles(project, name)));
+    const required = [
+        "package.json",
+        "declarations.json",
+        "dependencies.json",
+        ...[
+            "client.mjs",
+            "flow.mjs",
+            "steps.mjs",
+            "manifest.json",
+            "flow.mjs.__wf_tmp.js.debug.json",
+            "steps.mjs.debug.json",
+        ].map((name) => `artifacts/${name}`),
+    ];
+    if (required.some((name) => !files.some((file) => file.name === name)))
+        throw new Error("incomplete-workflow-bundle");
+    return files;
+}
+function bundleContents(repository, files) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        repository,
+        files: Object.fromEntries(files.map(({ name, bytes }) => [name, digest(bytes)])),
+    });
+}
+async function validatedId(input) {
+    if ((await readRetainedWorkflowBundle(input)).kind !== "available")
+        throw new Error("pinned-workflow-unavailable");
+    return input.id;
+}
+async function existingEntry(path) {
+    return lstat(path).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+}
+async function retainedBefore(input, contents) {
+    try {
+        const history = join(input.directory, ".history");
+        await mkdir(history, { recursive: true, mode: 0o700 });
+        if (!(await lstat(history)).isDirectory())
+            throw new Error("pinned-workflow-unavailable");
+        const directory = join(history, input.id);
+        const entry = await existingEntry(directory);
+        if (entry === undefined)
+            return false;
+        if (!entry.isDirectory())
+            throw new Error("pinned-workflow-unavailable");
+        const receipt = await regularFile(join(directory, "bundle.json"));
+        if (receipt.toString("utf8") !== contents)
+            throw new Error("pinned-workflow-unavailable");
+        return true;
+    }
+    catch {
+        throw new Error("pinned-workflow-unavailable");
+    }
+}
+async function rememberBundle(input, contents) {
+    const history = join(input.directory, ".history");
+    const temporary = await mkdtemp(join(history, ".pending-"));
+    try {
+        await writeFile(join(temporary, "bundle.json"), contents, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        await publishDirectory(temporary, join(history, input.id));
+        await retainedBefore(input, contents);
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+async function publishDirectory(from, to) {
+    await rename(from, to).catch((error) => {
+        if (error instanceof Error &&
+            "code" in error &&
+            ["ENOTEMPTY", "EEXIST"].includes(String(error.code)))
+            return;
+        throw error;
+    });
+}
+export async function retainWorkflowBundle(input) {
+    const repository = await realpath(input.repository);
+    const files = await projectFiles(input.project);
+    const contents = bundleContents(repository, files);
+    const id = digest(contents);
+    await mkdir(input.directory, { recursive: true, mode: 0o700 });
+    const destination = join(input.directory, id);
+    const lookup = { ...input, id };
+    if (await retainedBefore(lookup, contents))
+        return validatedId(lookup);
+    if (await existingEntry(destination)) {
+        await validatedId(lookup);
+        await rememberBundle(lookup, contents);
+        return id;
+    }
+    const temporary = await mkdtemp(join(input.directory, ".pending-"));
+    try {
+        for (const { name, bytes } of files) {
+            const path = join(temporary, name);
+            await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+            await writeFile(path, bytes, { flag: "wx", mode: 0o600 });
+        }
+        await writeFile(join(temporary, "bundle.json"), contents, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        await publishDirectory(temporary, destination);
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    await validatedId(lookup);
+    await rememberBundle(lookup, contents);
+    return id;
+}

package/dist/tools/workflow-candidate-counts.d.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+import { type CandidateSymbols } from "./workflow-candidate-syntax.ts";
+export interface Totals {
+    readonly knownCallCount: number;
+    readonly knownUnitTotal: number;
+}
+interface CountSymbols extends CandidateSymbols {
+    readonly localTotals?: (node: ts.Node) => Totals | undefined;
+}
+export declare function candidateEffectTotals(source: ts.Node, symbols: CountSymbols): Totals;
+export declare function candidateLoopRepetitions(node: ts.IterationStatement, symbols: CandidateSymbols): number | undefined;
+export {};

package/dist/tools/workflow-candidate-counts.js

@@ -0,0 +1,266 @@
+import ts from "typescript";
+import { protectedCall, helperCall, } from "./workflow-candidate-syntax.js";
+import { propertyName } from "./workflow-candidate-fields.js";
+import { referenceSymbol } from "./workflow-source-effects.js";
+const zero = { knownCallCount: 0, knownUnitTotal: 0 };
+function add(first, second) {
+    return {
+        knownCallCount: Math.min(Number.MAX_SAFE_INTEGER, first.knownCallCount + second.knownCallCount),
+        knownUnitTotal: Math.min(Number.MAX_SAFE_INTEGER, first.knownUnitTotal + second.knownUnitTotal),
+    };
+}
+function maximum(first, second) {
+    return {
+        knownCallCount: Math.max(first.knownCallCount, second.knownCallCount),
+        knownUnitTotal: Math.max(first.knownUnitTotal, second.knownUnitTotal),
+    };
+}
+function multiply(total, repetitions) {
+    return {
+        knownCallCount: Math.min(Number.MAX_SAFE_INTEGER, total.knownCallCount * repetitions),
+        knownUnitTotal: Math.min(Number.MAX_SAFE_INTEGER, total.knownUnitTotal * repetitions),
+    };
+}
+function units(node, symbols) {
+    if (helperCall(node, symbols))
+        return 1;
+    const argument = node.arguments[0];
+    if (!argument || !ts.isObjectLiteralExpression(argument))
+        return 0;
+    const property = argument.properties.find((entry) => entry.name && propertyName(entry.name) === "units");
+    if (!property || !ts.isPropertyAssignment(property))
+        return 0;
+    const value = Number(constantNumber(property.initializer));
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function loopIncrement(node, variable) {
+    if ((ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
+        ts.isIdentifier(node.operand) &&
+        node.operand.text === variable)
+        return unaryIncrement(node.operator);
+    return assignmentIncrement(node, variable);
+}
+function unaryIncrement(operator) {
+    if (operator === ts.SyntaxKind.PlusPlusToken)
+        return 1;
+    if (operator === ts.SyntaxKind.MinusMinusToken)
+        return -1;
+    return undefined;
+}
+function assignmentIncrement(node, variable) {
+    if (!ts.isBinaryExpression(node) ||
+        !ts.isIdentifier(node.left) ||
+        node.left.text !== variable)
+        return undefined;
+    const amount = constantNumber(node.right);
+    if (amount === undefined)
+        return undefined;
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken)
+        return amount;
+    if (node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken)
+        return -amount;
+    return undefined;
+}
+function constantNumber(node) {
+    if (ts.isParenthesizedExpression(node))
+        return constantNumber(node.expression);
+    if (ts.isNumericLiteral(node)) {
+        const value = Number(node.text);
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (!ts.isPrefixUnaryExpression(node))
+        return undefined;
+    const value = constantNumber(node.operand);
+    if (value === undefined)
+        return undefined;
+    if (node.operator === ts.SyntaxKind.PlusToken)
+        return value;
+    if (node.operator === ts.SyntaxKind.MinusToken)
+        return -value;
+    return undefined;
+}
+function rangeIterations(input) {
+    const { start, end, increment, operator } = input;
+    if (![
+        ts.SyntaxKind.LessThanToken,
+        ts.SyntaxKind.LessThanEqualsToken,
+        ts.SyntaxKind.GreaterThanToken,
+        ts.SyntaxKind.GreaterThanEqualsToken,
+    ].includes(operator))
+        return undefined;
+    let iterations = 0;
+    let value = start;
+    while (iterations < 101 && loopContinues(value, { end, operator })) {
+        iterations += 1;
+        value += increment;
+    }
+    return iterations;
+}
+function loopContinues(value, condition) {
+    const { end, operator } = condition;
+    if (operator === ts.SyntaxKind.LessThanToken)
+        return value < end;
+    if (operator === ts.SyntaxKind.LessThanEqualsToken)
+        return value <= end;
+    if (operator === ts.SyntaxKind.GreaterThanToken)
+        return value > end;
+    return value >= end;
+}
+function referencesCounter(node, context) {
+    if (!context.counter)
+        return false;
+    if (ts.isIdentifier(node) &&
+        referenceSymbol(node, { parent: node.parent, checker: context.checker }) ===
+            context.counter)
+        return true;
+    return (ts.forEachChild(node, (child) => referencesCounter(child, context) ? true : undefined) ?? false);
+}
+function assignmentTarget(node) {
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+        return node.left;
+    if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+        unaryIncrement(node.operator) !== undefined)
+        return node.operand;
+    return undefined;
+}
+function writesCounter(node, context) {
+    if (ts.isVariableDeclaration(node) && node.initializer !== undefined)
+        return referencesCounter(node.name, context);
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node))
+        return referencesCounter(node.initializer, context);
+    const target = assignmentTarget(node);
+    return target !== undefined && referencesCounter(target, context);
+}
+function uncertainLoopBody(node, context) {
+    if (ts.isBreakStatement(node) ||
+        ts.isContinueStatement(node) ||
+        ts.isReturnStatement(node) ||
+        ts.isThrowStatement(node) ||
+        writesCounter(node, context))
+        return true;
+    return (ts.forEachChild(node, (child) => uncertainLoopBody(child, context) ? true : undefined) ?? false);
+}
+function loopIterations(node, symbols) {
+    const { initializer, condition, incrementor } = node;
+    const declaration = loopStart(initializer);
+    if (!declaration)
+        return undefined;
+    if (!condition || !ts.isBinaryExpression(condition))
+        return undefined;
+    if (!ts.isIdentifier(condition.left) ||
+        condition.left.text !== declaration.variable.text)
+        return undefined;
+    if (!incrementor)
+        return undefined;
+    const end = constantNumber(condition.right);
+    if (end === undefined)
+        return undefined;
+    const increment = loopIncrement(incrementor, declaration.variable.text);
+    if (increment === undefined)
+        return undefined;
+    if (uncertainLoopBody(node.statement, {
+        checker: symbols.checker,
+        counter: symbols.checker.getSymbolAtLocation(declaration.variable),
+    }))
+        return undefined;
+    return rangeIterations({
+        start: declaration.start,
+        end,
+        increment,
+        operator: condition.operatorToken.kind,
+    });
+}
+function loopStart(initializer) {
+    if (!initializer ||
+        !ts.isVariableDeclarationList(initializer) ||
+        initializer.declarations.length !== 1)
+        return undefined;
+    const declaration = initializer.declarations[0];
+    if (!declaration ||
+        !ts.isIdentifier(declaration.name) ||
+        !declaration.initializer)
+        return undefined;
+    const start = constantNumber(declaration.initializer);
+    if (start === undefined)
+        return undefined;
+    return {
+        variable: declaration.name,
+        start,
+    };
+}
+export function candidateEffectTotals(source, symbols) {
+    function count(node) {
+        if (!node)
+            return zero;
+        if (ts.isIfStatement(node))
+            return add(count(node.expression), maximum(count(node.thenStatement), count(node.elseStatement)));
+        if (ts.isConditionalExpression(node))
+            return add(count(node.condition), maximum(count(node.whenTrue), count(node.whenFalse)));
+        if (ts.isForStatement(node)) {
+            const iterations = loopIterations(node, symbols) ?? 1;
+            const body = count(node.statement);
+            const headers = add(count(node.initializer), add(count(node.condition), count(node.incrementor)));
+            return add(headers, multiply(body, iterations));
+        }
+        if (ts.isForOfStatement(node) &&
+            ts.isArrayLiteralExpression(node.expression))
+            return add(count(node.expression), multiply(add(count(node.initializer), count(node.statement)), arrayIterations(node, symbols)));
+        if (ts.isSwitchStatement(node))
+            return add(count(node.expression), switchTotals(node.caseBlock, count));
+        return nodeTotals(node, { symbols, count });
+    }
+    return count(source);
+}
+function nodeTotals(node, input) {
+    const local = input.symbols.localTotals?.(node);
+    if (local && ts.isFunctionLike(node))
+        return local;
+    let total = local ??
+        (protectedCall(node, input.symbols)
+            ? { knownCallCount: 1, knownUnitTotal: units(node, input.symbols) }
+            : zero);
+    ts.forEachChild(node, (child) => {
+        total = add(total, input.count(child));
+    });
+    return total;
+}
+export function candidateLoopRepetitions(node, symbols) {
+    if (ts.isForStatement(node))
+        return loopIterations(node, symbols);
+    if (ts.isForOfStatement(node) &&
+        ts.isArrayLiteralExpression(node.expression) &&
+        !uncertainLoopBody(node.statement, {
+            checker: symbols.checker,
+            counter: undefined,
+        }))
+        return node.expression.elements.length;
+    return undefined;
+}
+function arrayIterations(node, symbols) {
+    if (!ts.isArrayLiteralExpression(node.expression))
+        return 1;
+    return uncertainLoopBody(node.statement, {
+        checker: symbols.checker,
+        counter: undefined,
+    })
+        ? 1
+        : node.expression.elements.length;
+}
+function switchTotals(block, count) {
+    let suffix = zero;
+    let largest = zero;
+    let conditions = zero;
+    for (const clause of [...block.clauses].reverse()) {
+        if (ts.isCaseClause(clause))
+            conditions = add(conditions, count(clause.expression));
+        const ends = clause.statements.some((node) => ts.isBreakStatement(node) ||
+            ts.isReturnStatement(node) ||
+            ts.isThrowStatement(node));
+        const statements = clause.statements.reduce((total, statement) => add(total, count(statement)), zero);
+        suffix = add(statements, ends ? zero : suffix);
+        largest = maximum(largest, suffix);
+    }
+    return add(conditions, largest);
+}

package/dist/tools/workflow-candidate-fields.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export declare function propertyName(name: ts.PropertyName): string | undefined;
+export declare function propertyInitializer(node: ts.Node | undefined, field: string): ts.Expression | undefined;
+export declare function literalField(node: ts.Node | undefined, field: string): string | null;
+export declare function invalidFields(object: ts.ObjectLiteralExpression): boolean;

package/dist/tools/workflow-candidate-fields.js

@@ -0,0 +1,24 @@
+import ts from "typescript";
+export function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    return undefined;
+}
+export function propertyInitializer(node, field) {
+    if (!node || !ts.isObjectLiteralExpression(node))
+        return undefined;
+    const property = node.properties.find((entry) => entry.name && propertyName(entry.name) === field);
+    return property && ts.isPropertyAssignment(property)
+        ? property.initializer
+        : undefined;
+}
+export function literalField(node, field) {
+    const value = propertyInitializer(node, field);
+    return value && ts.isStringLiteral(value) ? value.text : null;
+}
+export function invalidFields(object) {
+    const names = object.properties.map((entry) => entry.name && propertyName(entry.name));
+    return (names.includes(undefined) ||
+        new Set(names).size !== names.length ||
+        object.properties.some((entry) => !ts.isPropertyAssignment(entry)));
+}

package/dist/tools/workflow-candidate-helper-counts.d.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+import { type Totals } from "./workflow-candidate-counts.ts";
+import { type CandidateSymbols } from "./workflow-candidate-syntax.ts";
+export declare function helperEffectTotals(input: {
+    readonly symbols: CandidateSymbols;
+    readonly sources: readonly ts.SourceFile[];
+}): {
+    readonly totals?: Totals;
+    readonly unsupportedForms: readonly string[];
+};

package/dist/tools/workflow-candidate-helper-counts.js

@@ -0,0 +1,129 @@
+import ts from "typescript";
+import { candidateEffectTotals, candidateLoopRepetitions, } from "./workflow-candidate-counts.js";
+import { protectedCall, } from "./workflow-candidate-syntax.js";
+import { resolvedSymbol } from "./workflow-candidate-program.js";
+import { referenceSymbol, typeOnlyEffectNode, } from "./workflow-source-effects.js";
+const zero = { knownCallCount: 0, knownUnitTotal: 0 };
+export function helperEffectTotals(input) {
+    const { symbols, sources } = input;
+    const unsupportedForms = [];
+    if (sources.length === 1)
+        return { unsupportedForms };
+    const active = new Set();
+    const totals = new Map();
+    const functions = localFunctions(sources);
+    const functionAt = (node) => localFunctionAt(node, { checker: symbols.checker, functions });
+    function count(declaration) {
+        const cached = totals.get(declaration);
+        if (cached)
+            return cached;
+        if (active.has(declaration)) {
+            unsupportedForms.push("recursive-helper-effects");
+            return zero;
+        }
+        active.add(declaration);
+        const result = candidateEffectTotals(declaration, {
+            ...symbols,
+            localTotals: (node) => {
+                if (ts.isFunctionLike(node) && node !== declaration)
+                    return zero;
+                if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+                    return undefined;
+                const called = functionAt(node.expression);
+                return called && effectful.has(called) ? count(called) : undefined;
+            },
+        });
+        active.delete(declaration);
+        totals.set(declaration, result);
+        return result;
+    }
+    const effectful = effectfulFunctions({ functions, functionAt, symbols });
+    if ([...effectful].every((entry) => entry.getSourceFile() === symbols.source))
+        return { unsupportedForms };
+    for (const source of sources)
+        inspectHelperReferences(source, {
+            functionAt,
+            effectful,
+            symbols,
+            unsupportedForms,
+        });
+    for (const declaration of effectful)
+        count(declaration);
+    const workflow = [...functions].find((entry) => entry.getSourceFile() === symbols.source &&
+        (ts.getCombinedModifierFlags(entry) & ts.ModifierFlags.Export) !== 0);
+    return { totals: workflow ? count(workflow) : zero, unsupportedForms };
+}
+function localFunctions(sources) {
+    return new Set(sources.flatMap((source) => source.statements.filter((node) => ts.isFunctionDeclaration(node) && node.body !== undefined)));
+}
+function localFunctionAt(node, input) {
+    const symbol = resolvedSymbol(input.checker, referenceSymbol(node, {
+        parent: node.parent,
+        checker: input.checker,
+    }));
+    return symbol?.declarations?.find((entry) => ts.isFunctionDeclaration(entry) && input.functions.has(entry));
+}
+function effectfulFunctions(input) {
+    const effectful = new Set();
+    const calls = (node) => {
+        if (typeOnlyEffectNode(node))
+            return false;
+        if (protectedCall(node, input.symbols))
+            return true;
+        const called = ts.isIdentifier(node) ? input.functionAt(node) : undefined;
+        if (called && effectful.has(called))
+            return true;
+        return ts.forEachChild(node, (child) => calls(child) || undefined) ?? false;
+    };
+    let previous = -1;
+    while (previous !== effectful.size) {
+        previous = effectful.size;
+        for (const declaration of input.functions)
+            if (calls(declaration))
+                effectful.add(declaration);
+    }
+    return effectful;
+}
+function inspectHelperReferences(source, input) {
+    function visit(node) {
+        if (typeOnlyEffectNode(node))
+            return;
+        if (source !== input.symbols.source &&
+            protectedCall(node, input.symbols) &&
+            !checkedHelperContext(node, input.symbols))
+            input.unsupportedForms.push("uncheckable-helper-effects");
+        const declaration = ts.isIdentifier(node)
+            ? input.functionAt(node)
+            : undefined;
+        if (declaration &&
+            input.effectful.has(declaration) &&
+            ts.isIdentifier(node) &&
+            !checkedHelperReference(node, input.symbols))
+            input.unsupportedForms.push("uncheckable-helper-effects");
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+}
+function checkedHelperReference(node, symbols) {
+    if (ts.isFunctionDeclaration(node.parent) && node.parent.name === node)
+        return true;
+    if (ts.isImportSpecifier(node.parent))
+        return true;
+    if (!ts.isCallExpression(node.parent) ||
+        node.parent.expression !== node ||
+        node.parent.questionDotToken !== undefined)
+        return false;
+    return checkedHelperContext(node.parent, symbols);
+}
+function checkedHelperContext(node, symbols) {
+    let parent = node;
+    while (!ts.isFunctionLike(parent)) {
+        if (ts.isSourceFile(parent))
+            return false;
+        if (ts.isIterationStatement(parent, false) &&
+            candidateLoopRepetitions(parent, symbols) === undefined)
+            return false;
+        parent = parent.parent;
+    }
+    return ts.isFunctionDeclaration(parent) && ts.isSourceFile(parent.parent);
+}

package/dist/tools/workflow-candidate-program.d.ts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+export declare const candidatePackageRoot: string;
+export interface CandidatePackageOptions {
+    readonly packageRoot?: string;
+    readonly helpers?: Readonly<Record<string, string>>;
+}
+export declare function resolvedSymbol(checker: ts.TypeChecker, symbol: ts.Symbol | undefined): ts.Symbol | undefined;
+export declare function candidateProgram(text: string, installed?: CandidatePackageOptions): {
+    readonly program: ts.Program;
+    readonly source: ts.SourceFile;
+    readonly sources: readonly ts.SourceFile[];
+    readonly modules: ReadonlyMap<string, ts.SourceFile>;
+};