septima-lang 0.0.7 → 0.0.9

package/dist/src/runtime.js

@@ -0,0 +1,351 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runtime = void 0;
+const ast_node_1 = require("./ast-node");
+const extract_message_1 = require("./extract-message");
+const fail_me_1 = require("./fail-me");
+const should_never_happen_1 = require("./should-never-happen");
+const Stack = __importStar(require("./stack"));
+const switch_on_1 = require("./switch-on");
+const value_1 = require("./value");
+class SymbolFrame {
+    constructor(symbol, placeholder, earlier) {
+        this.symbol = symbol;
+        this.placeholder = placeholder;
+        this.earlier = earlier;
+    }
+    lookup(sym) {
+        if (this.symbol === sym) {
+            const ret = this.placeholder.destination;
+            if (ret === undefined) {
+                throw new Error(`Unresolved definition: ${this.symbol}`);
+            }
+            return ret;
+        }
+        return this.earlier.lookup(sym);
+    }
+    export() {
+        const ret = this.earlier.export();
+        ret[this.symbol] = this.placeholder.destination?.export() ?? (0, fail_me_1.failMe)(`Unbounded symbol: ${this.symbol}`);
+        return ret;
+    }
+    exportValue() {
+        const ret = this.earlier.exportValue();
+        ret[this.symbol] = this.placeholder.destination ?? (0, fail_me_1.failMe)(`Unbounded symbol: ${this.symbol}`);
+        return ret;
+    }
+}
+class EmptySymbolTable {
+    lookup(sym) {
+        throw new Error(`Symbol ${sym} was not found`);
+    }
+    export() {
+        return {};
+    }
+    exportValue() {
+        return {};
+    }
+}
+class Runtime {
+    constructor(root, verbosity = 'quiet', preimports, getAstOf, args) {
+        this.root = root;
+        this.verbosity = verbosity;
+        this.preimports = preimports;
+        this.getAstOf = getAstOf;
+        this.args = args;
+        this.stack = undefined;
+    }
+    buildInitialSymbolTable(generateTheArgsObject) {
+        const empty = new EmptySymbolTable();
+        const keys = value_1.Value.foreign(o => o.keys());
+        const entries = value_1.Value.foreign(o => o.entries());
+        const fromEntries = value_1.Value.foreign(o => o.fromEntries());
+        let lib = new SymbolFrame('Object', { destination: value_1.Value.obj({ keys, entries, fromEntries }) }, empty);
+        if (generateTheArgsObject) {
+            lib = new SymbolFrame('args', { destination: value_1.Value.from(this.args) }, lib);
+        }
+        for (const [importName, importValue] of Object.entries(this.preimports)) {
+            lib = new SymbolFrame(importName, { destination: importValue }, lib);
+        }
+        return lib;
+    }
+    compute() {
+        try {
+            const value = this.evalNode(this.root, this.buildInitialSymbolTable(true));
+            return { value };
+        }
+        catch (e) {
+            const trace = [];
+            for (let curr = this.stack; curr; curr = curr?.next) {
+                trace.push(curr.ast);
+            }
+            return {
+                expressionTrace: trace,
+                errorMessage: (0, extract_message_1.extractMessage)(e),
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                stack: e.stack,
+            };
+        }
+    }
+    evalNode(ast, table) {
+        this.stack = Stack.push(ast, this.stack);
+        let ret = this.evalNodeImpl(ast, table);
+        if (ret.isSink() && !ret.span()) {
+            ret = ret.bindToSpan((0, ast_node_1.span)(ast));
+        }
+        (0, switch_on_1.switchOn)(this.verbosity, {
+            quiet: () => { },
+            trace: () => {
+                // eslint-disable-next-line no-console
+                console.log(`output of <|${(0, ast_node_1.show)(ast)}|> is ${JSON.stringify(ret)}  // ${ast.tag}`);
+            },
+        });
+        this.stack = Stack.pop(this.stack);
+        return ret;
+    }
+    importDefinitions(pathToImportFrom) {
+        const ast = this.getAstOf(pathToImportFrom);
+        const exp = ast.expression;
+        const imports = ast.imports;
+        if (exp.tag === 'arrayLiteral' ||
+            exp.tag === 'binaryOperator' ||
+            exp.tag === 'dot' ||
+            exp.tag === 'export*' ||
+            exp.tag === 'functionCall' ||
+            exp.tag === 'ident' ||
+            exp.tag === 'if' ||
+            exp.tag === 'ternary' ||
+            exp.tag === 'indexAccess' ||
+            exp.tag === 'lambda' ||
+            exp.tag === 'literal' ||
+            exp.tag === 'objectLiteral' ||
+            exp.tag === 'unaryOperator' ||
+            exp.tag === 'unit') {
+            // TODO(imaman): throw an error on non-exporting unit?
+            return value_1.Value.obj({});
+        }
+        if (exp.tag === 'topLevelExpression') {
+            const unit = {
+                tag: 'unit',
+                imports,
+                expression: { tag: 'topLevelExpression', definitions: exp.definitions, computation: { tag: 'export*' } },
+            };
+            return this.evalNode(unit, this.buildInitialSymbolTable(false));
+        }
+        (0, should_never_happen_1.shouldNeverHappen)(exp);
+    }
+    evalNodeImpl(ast, table) {
+        if (ast.tag === 'unit') {
+            let newTable = table;
+            for (const imp of ast.imports) {
+                const o = this.importDefinitions(imp.pathToImportFrom.text);
+                newTable = new SymbolFrame(imp.ident.t.text, { destination: o }, newTable);
+            }
+            return this.evalNode(ast.expression, newTable);
+        }
+        if (ast.tag === 'topLevelExpression') {
+            let newTable = table;
+            for (const def of ast.definitions) {
+                const name = def.ident.t.text;
+                const placeholder = { destination: undefined };
+                newTable = new SymbolFrame(name, placeholder, newTable);
+                const v = this.evalNode(def.value, newTable);
+                placeholder.destination = v;
+            }
+            if (ast.computation) {
+                return this.evalNode(ast.computation, newTable);
+            }
+            return value_1.Value.str('');
+        }
+        if (ast.tag === 'export*') {
+            return value_1.Value.obj(table.exportValue());
+        }
+        if (ast.tag === 'binaryOperator') {
+            const lhs = this.evalNode(ast.lhs, table);
+            if (ast.operator === '||') {
+                return lhs.or(() => this.evalNode(ast.rhs, table));
+            }
+            if (ast.operator === '&&') {
+                return lhs.and(() => this.evalNode(ast.rhs, table));
+            }
+            if (ast.operator === '??') {
+                return lhs.unsink(() => this.evalNode(ast.rhs, table));
+            }
+            const rhs = this.evalNode(ast.rhs, table);
+            if (ast.operator === '!=') {
+                return lhs.equalsTo(rhs).not();
+            }
+            if (ast.operator === '==') {
+                return lhs.equalsTo(rhs);
+            }
+            if (ast.operator === '<=') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('<=');
+            }
+            if (ast.operator === '<') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('<');
+            }
+            if (ast.operator === '>=') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('>=');
+            }
+            if (ast.operator === '>') {
+                const comp = lhs.order(rhs);
+                return comp.isToZero('>');
+            }
+            if (ast.operator === '%') {
+                return lhs.modulo(rhs);
+            }
+            if (ast.operator === '*') {
+                return lhs.times(rhs);
+            }
+            if (ast.operator === '**') {
+                return lhs.power(rhs);
+            }
+            if (ast.operator === '+') {
+                return lhs.plus(rhs);
+            }
+            if (ast.operator === '-') {
+                return lhs.minus(rhs);
+            }
+            if (ast.operator === '/') {
+                return lhs.over(rhs);
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.operator);
+        }
+        if (ast.tag === 'unaryOperator') {
+            const operand = this.evalNode(ast.operand, table);
+            if (ast.operator === '!') {
+                return operand.not();
+            }
+            if (ast.operator === '+') {
+                // We intentionally do <0 + operand> instead of just <operand>. This is due to type-checking: the latter will
+                // evaluate to the operand as-is, making expression such as `+true` dynamically valid (which is not the desired
+                // behavior)
+                return value_1.Value.num(0).plus(operand);
+            }
+            if (ast.operator === '-') {
+                return operand.negate();
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.operator);
+        }
+        if (ast.tag === 'ident') {
+            return table.lookup(ast.t.text);
+        }
+        if (ast.tag === 'literal') {
+            if (ast.type === 'bool') {
+                // TODO(imaman): stricter checking of 'false'
+                return value_1.Value.bool(ast.t.text === 'true' ? true : false);
+            }
+            if (ast.type === 'num') {
+                return value_1.Value.num(Number(ast.t.text));
+            }
+            if (ast.type === 'sink!!') {
+                return value_1.Value.sink(undefined, this.stack, table);
+            }
+            if (ast.type === 'sink!') {
+                return value_1.Value.sink(undefined, this.stack);
+            }
+            if (ast.type === 'sink') {
+                return value_1.Value.sink();
+            }
+            if (ast.type === 'str') {
+                return value_1.Value.str(ast.t.text);
+            }
+            (0, should_never_happen_1.shouldNeverHappen)(ast.type);
+        }
+        if (ast.tag === 'arrayLiteral') {
+            const arr = [];
+            for (const curr of ast.parts) {
+                if (curr.tag === 'element') {
+                    arr.push(this.evalNode(curr.v, table));
+                }
+                else if (curr.tag === 'spread') {
+                    const v = this.evalNode(curr.v, table);
+                    arr.push(...v.assertArr());
+                }
+                else {
+                    (0, should_never_happen_1.shouldNeverHappen)(curr);
+                }
+            }
+            return value_1.Value.arr(arr);
+        }
+        if (ast.tag === 'objectLiteral') {
+            const entries = ast.parts.flatMap(at => {
+                if (at.tag === 'hardName') {
+                    return [[at.k.t.text, this.evalNode(at.v, table)]];
+                }
+                if (at.tag === 'computedName') {
+                    return [[this.evalNode(at.k, table).assertStr(), this.evalNode(at.v, table)]];
+                }
+                if (at.tag === 'spread') {
+                    const o = this.evalNode(at.o, table);
+                    return Object.entries(o.assertObj());
+                }
+                (0, should_never_happen_1.shouldNeverHappen)(at);
+            });
+            // TODO(imaman): verify type of all keys (strings, maybe also numbers)
+            return value_1.Value.obj(Object.fromEntries(entries));
+        }
+        if (ast.tag === 'lambda') {
+            return value_1.Value.lambda(ast, table);
+        }
+        if (ast.tag === 'functionCall') {
+            const argValues = ast.actualArgs.map(a => this.evalNode(a, table));
+            const callee = this.evalNode(ast.callee, table);
+            return this.call(callee, argValues);
+        }
+        if (ast.tag === 'if' || ast.tag === 'ternary') {
+            const c = this.evalNode(ast.condition, table);
+            return c.ifElse(() => this.evalNode(ast.positive, table), () => this.evalNode(ast.negative, table));
+        }
+        if (ast.tag === 'dot') {
+            const rec = this.evalNode(ast.receiver, table);
+            if (rec === undefined || rec === null) {
+                throw new Error(`Cannot access attribute .${ast.ident.t.text} of ${rec}`);
+            }
+            return rec.access(ast.ident.t.text, (callee, args) => this.call(callee, args));
+        }
+        if (ast.tag === 'indexAccess') {
+            const rec = this.evalNode(ast.receiver, table);
+            const index = this.evalNode(ast.index, table);
+            return rec.access(index, (callee, args) => this.call(callee, args));
+        }
+        (0, should_never_happen_1.shouldNeverHappen)(ast);
+    }
+    call(callee, argValues) {
+        return callee.call(argValues, (names, body, lambdaTable) => {
+            if (names.length > argValues.length) {
+                throw new Error(`Arg list length mismatch: expected ${names.length} but got ${argValues.length}`);
+            }
+            const newTable = names.reduce((t, n, i) => new SymbolFrame(n, { destination: argValues[i] }, t), lambdaTable);
+            return this.evalNode(body, newTable);
+        });
+    }
+}
+exports.Runtime = Runtime;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/src/scanner.d.ts

@@ -0,0 +1,23 @@
+import { Location } from './location';
+import { SourceCode } from './source-code';
+export interface Token {
+    readonly text: string;
+    readonly location: Location;
+}
+export declare class Scanner {
+    readonly sourceCode: SourceCode;
+    private offset;
+    constructor(sourceCode: SourceCode, offset?: number);
+    get sourceRef(): string;
+    private curr;
+    private eatWhitespace;
+    eof(): boolean;
+    synopsis(): {
+        position: number;
+        lookingAt: string;
+    };
+    headMatches(...patterns: (RegExp | string)[]): boolean;
+    consume(r: RegExp | string, eatWhitespace?: boolean): Token;
+    consumeIf(r: RegExp | string, eatWhitespace?: boolean): Token | undefined;
+    private match;
+}

package/dist/src/scanner.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+class Scanner {
+    constructor(sourceCode, offset = 0) {
+        this.sourceCode = sourceCode;
+        this.offset = offset;
+        if (this.offset === 0) {
+            this.eatWhitespace();
+        }
+    }
+    get sourceRef() {
+        return this.sourceCode.sourceRef(this.sourceCode.expandToEndOfLine({ offset: this.offset }));
+    }
+    curr() {
+        return this.sourceCode.input.substring(this.offset);
+    }
+    eatWhitespace() {
+        while (true) {
+            if (this.consumeIf(/\s*/, false)) {
+                continue;
+            }
+            if (this.consumeIf('//', false)) {
+                this.consume(/[^\n]*/, false);
+                continue;
+            }
+            return;
+        }
+    }
+    eof() {
+        return this.offset >= this.sourceCode.input.length;
+    }
+    synopsis() {
+        const c = this.curr();
+        let lookingAt = c.substring(0, 20);
+        if (lookingAt.length !== c.length) {
+            lookingAt = `${lookingAt}...`;
+        }
+        return {
+            position: this.offset,
+            lookingAt,
+        };
+    }
+    headMatches(...patterns) {
+        const alt = new Scanner(this.sourceCode, this.offset);
+        for (const p of patterns) {
+            const t = alt.consumeIf(p, true);
+            if (t === undefined) {
+                return false;
+            }
+        }
+        return true;
+    }
+    consume(r, eatWhitespace = true) {
+        const text = this.match(r);
+        if (text === undefined) {
+            throw new Error(`Expected ${r} ${this.sourceRef}`);
+        }
+        const offset = this.offset;
+        this.offset += text.length;
+        if (eatWhitespace) {
+            this.eatWhitespace();
+        }
+        return { location: { offset }, text };
+    }
+    consumeIf(r, eatWhitespace = true) {
+        const ret = this.match(r);
+        if (!ret) {
+            return undefined;
+        }
+        return this.consume(r, eatWhitespace);
+    }
+    match(r) {
+        if (typeof r === 'string') {
+            if (this.curr().startsWith(r)) {
+                return r;
+            }
+            return undefined;
+        }
+        const m = this.curr().match(r);
+        if (m && m.index === 0) {
+            return m[0];
+        }
+        return undefined;
+    }
+}
+exports.Scanner = Scanner;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/septima.d.ts

@@ -0,0 +1,32 @@
+import { Unit } from './ast-node';
+import { Parser } from './parser';
+import { Result, ResultSink } from './result';
+import { Verbosity } from './runtime';
+interface Options {
+    /**
+     * A callback function to be invoked when the Septima program evaluated to `sink`. Allows the caller to determine
+     * which value will be returned in that case. For instance, passing `() => undefined` will translate a `sink` value
+     * to `undefined`. The default behavior is to throw an error.
+     */
+    onSink?: (res: ResultSink) => unknown;
+}
+export declare class Septima {
+    /**
+     * Runs a Septima program and returns the value it evaluates to. If it evaluates to `sink`, returns the value computed
+     * by `options.onSink()` - if present, or throws an error - otherwise.
+     *
+     * This method is the simplest way to evaluate a Septima program, and it fits many common use cases. One can also use
+     * `.compute()` to get additional details about the execution.
+     *
+     * @param input the source code of the Septima program
+     * @param options
+     * @returns the value that `input` evaluates to
+     */
+    static run(input: string, options?: Options, args?: Record<string, unknown>): unknown;
+    constructor();
+    computeModule(moduleName: string, moduleReader: (m: string) => string, args: Record<string, unknown>): Result;
+    compute(input: string, preimports: Record<string, string> | undefined, verbosity: Verbosity | undefined, args: Record<string, unknown>): Result;
+    private computeImpl;
+}
+export declare function parse(arg: string | Parser): Unit;
+export {};

package/dist/src/septima.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.Septima = void 0;
+const parser_1 = require("./parser");
+const result_1 = require("./result");
+const runtime_1 = require("./runtime");
+const scanner_1 = require("./scanner");
+const should_never_happen_1 = require("./should-never-happen");
+const source_code_1 = require("./source-code");
+class Septima {
+    /**
+     * Runs a Septima program and returns the value it evaluates to. If it evaluates to `sink`, returns the value computed
+     * by `options.onSink()` - if present, or throws an error - otherwise.
+     *
+     * This method is the simplest way to evaluate a Septima program, and it fits many common use cases. One can also use
+     * `.compute()` to get additional details about the execution.
+     *
+     * @param input the source code of the Septima program
+     * @param options
+     * @returns the value that `input` evaluates to
+     */
+    static run(input, options, args = {}) {
+        const onSink = options?.onSink ??
+            ((r) => {
+                throw new Error(r.message);
+            });
+        const res = new Septima().compute(input, {}, 'quiet', args);
+        if (res.tag === 'ok') {
+            return res.value;
+        }
+        if (res.tag === 'sink') {
+            return onSink(res);
+        }
+        (0, should_never_happen_1.shouldNeverHappen)(res);
+    }
+    constructor() { }
+    computeModule(moduleName, moduleReader, args) {
+        const input = moduleReader(moduleName);
+        const sourceCode = new source_code_1.SourceCode(input);
+        const value = this.computeImpl(sourceCode, 'quiet', {}, moduleReader, args);
+        if (!value.isSink()) {
+            return { value: value.export(), tag: 'ok' };
+        }
+        return new result_1.ResultSinkImpl(value, sourceCode);
+    }
+    compute(input, preimports = {}, verbosity = 'quiet', args) {
+        const lib = {};
+        for (const [importName, importCode] of Object.entries(preimports)) {
+            const sourceCode = new source_code_1.SourceCode(importCode);
+            const value = this.computeImpl(sourceCode, verbosity, {}, undefined, {});
+            if (value.isSink()) {
+                // TODO(imaman): cover!
+                const r = new result_1.ResultSinkImpl(value, sourceCode);
+                throw new Error(`preimport (${importName}) evaluated to sink: ${r.message}`);
+            }
+            lib[importName] = value;
+        }
+        const sourceCode = new source_code_1.SourceCode(input);
+        const value = this.computeImpl(sourceCode, verbosity, lib, undefined, args);
+        if (!value.isSink()) {
+            return { value: value.export(), tag: 'ok' };
+        }
+        return new result_1.ResultSinkImpl(value, sourceCode);
+    }
+    computeImpl(sourceCode, verbosity, lib, moduleReader, args) {
+        const scanner = new scanner_1.Scanner(sourceCode);
+        const parser = new parser_1.Parser(scanner);
+        const ast = parse(parser);
+        const getAstOf = (fileName) => {
+            if (!moduleReader) {
+                throw new Error(`cannot read modules`);
+            }
+            return parse(moduleReader(fileName));
+        };
+        const runtime = new runtime_1.Runtime(ast, verbosity, lib, getAstOf, args);
+        const c = runtime.compute();
+        if (c.value) {
+            return c.value;
+        }
+        const runtimeErrorMessage = `${c.errorMessage} when evaluating:\n${sourceCode.formatTrace(c.expressionTrace)}`;
+        throw new Error(runtimeErrorMessage);
+    }
+}
+exports.Septima = Septima;
+function parse(arg) {
+    const parser = typeof arg === 'string' ? new parser_1.Parser(new scanner_1.Scanner(new source_code_1.SourceCode(arg))) : arg;
+    const ast = parser.parse();
+    return ast;
+}
+exports.parse = parse;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/should-never-happen.d.ts

@@ -0,0 +1 @@
+export declare function shouldNeverHappen(n: never): never;

package/dist/src/should-never-happen.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNeverHappen = void 0;
+function shouldNeverHappen(n) {
+    // This following line never gets executed. It is here just to make the compiler happy.
+    throw new Error(`This should never happen ${n}`);
+}
+exports.shouldNeverHappen = shouldNeverHappen;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hvdWxkLW5ldmVyLWhhcHBlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zaG91bGQtbmV2ZXItaGFwcGVuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLFNBQWdCLGlCQUFpQixDQUFDLENBQVE7SUFDeEMsdUZBQXVGO0lBQ3ZGLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLENBQUMsRUFBRSxDQUFDLENBQUE7QUFDbEQsQ0FBQztBQUhELDhDQUdDIn0=

package/dist/src/source-code.d.ts

@@ -0,0 +1,19 @@
+import { AstNode } from './ast-node';
+import { Location, Location2d, Span } from './location';
+export declare class SourceCode {
+    readonly input: string;
+    constructor(input: string);
+    formatTrace(trace: AstNode[]): string;
+    sourceRefOfLocation(loc: Location): string;
+    sourceRef(span: Span | undefined): string;
+    formatSpan(span: Span): string;
+    private interestingPart;
+    resolveLocation(loc: Location): Location2d;
+    /**
+     * Returns a span starting a the given input location that runs all the way to the end of the line. Specifically, the
+     * returned span's `.to` location will point at the character (in the same line as `loc`) that is immediately before
+     * the terminating newline character.
+     */
+    expandToEndOfLine(loc: Location): Span;
+    lineAt(loc: Location): string;
+}