@wrtnlabs/evidence 0.0.0

package/lib/parsers/EvidenceParser.js

@@ -0,0 +1,307 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceParser = void 0;
+const _isTypeUint32_1 = __importStar(require("typia/lib/internal/_isTypeUint32"));
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const typia_1 = __importDefault(require("typia"));
+const web_tree_sitter_1 = require("web-tree-sitter");
+const EvidenceLanguageRegistry_1 = require("./EvidenceLanguageRegistry");
+const EvidenceParseSession_1 = require("./EvidenceParseSession");
+const EvidenceParserError_1 = require("./EvidenceParserError");
+const ParserSlots_1 = require("../internal/ParserSlots");
+const TreeSitterAssets_1 = require("../internal/TreeSitterAssets");
+const TreeSitterRange_1 = require("../internal/TreeSitterRange");
+const TreeSitterRuntime_1 = require("../internal/TreeSitterRuntime");
+/**
+ * Owns bounded Tree-sitter parse sessions with lazy, verified grammar acquisition.
+ *
+ * Create a parser for a group of source extractions, call `parse` for each file,
+ * then await `close`. Grammar selection uses the configured artifact and filename;
+ * acquisition starts only when that grammar is needed. Construction and metadata
+ * inspection do not initialize a language or parse source.
+ *
+ * Each request owns a native parser and tree. Its callback receives a borrowed
+ * session only after syntax completeness is established, and must return data
+ * that no longer depends on native objects. The concurrency slot remains held
+ * during asynchronous callback work, so a callback must not await another parse
+ * or close on the same pool: that work can wait for the callback's own slot.
+ *
+ * Cleanup runs for successful extraction and every failure path. Closing rejects
+ * new requests and waits for accepted callbacks; immutable process-wide grammar
+ * data can remain cached for later runtimes.
+ *
+ * @example
+ * const parser: EvidenceParser = new EvidenceParser({ concurrency: 2 });
+ * try {
+ *   const range: IEvidenceSourceRange = await parser.parse(
+ *     { type: "typescript", file: "api.ts", content: "export const value = 1;" },
+ *     (session: EvidenceParseSession): IEvidenceSourceRange =>
+ *       session.range(session.root),
+ *   );
+ * } finally {
+ *   await parser.close();
+ * }
+ */
+class EvidenceParser {
+    /**
+     * Asset provider for pinned grammar metadata and verified bytes.
+     *
+     * Keeping one provider per runtime shares acquisition work without loading
+     * every registered grammar when the parser is constructed.
+     */
+    assets = new TreeSitterAssets_1.TreeSitterAssets();
+    /**
+     * Admission queue and lifecycle boundary for parse callbacks.
+     *
+     * A slot covers acquisition, parsing, and the callback's asynchronous lifetime.
+     * Closing this queue prevents new work before native resources are discarded.
+     */
+    slots;
+    /**
+     * In-flight or fulfilled language loads keyed by grammar ID.
+     *
+     * Concurrent requests share a load. A rejected entry is removed so a later
+     * request can recover after acquisition or initialization becomes available.
+     */
+    languages = new Map();
+    /**
+     * Grammar IDs successfully loaded by this runtime.
+     *
+     * State inspection reports this history separately from pending loads, so a
+     * failed acquisition is not advertised as a usable language.
+     */
+    loaded = new Set();
+    /**
+     * Creates a lazy parser pool with a bounded callback count.
+     *
+     * The default permits four active requests. Options are validated immediately,
+     * but grammar acquisition and native parser allocation wait for `parse`.
+     */
+    constructor(options = {}) {
+        this.slots = new ParserSlots_1.ParserSlots((() => {
+            const _ao0 = (input, _path, _exceptionable = true) => undefined === input.concurrency || "number" === typeof input.concurrency && (_isTypeUint32_1._isTypeUint32(input.concurrency) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".concurrency",
+                expected: "number & Type<\"uint32\">",
+                value: input.concurrency
+            }, _errorFactory)) && (1 <= input.concurrency || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".concurrency",
+                expected: "number & Minimum<1>",
+                value: input.concurrency
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".concurrency",
+                expected: "((number & Type<\"uint32\"> & Minimum<1>) | undefined)",
+                value: input.concurrency
+            }, _errorFactory);
+            const _io0 = input => undefined === input.concurrency || "number" === typeof input.concurrency && (_isTypeUint32_1._isTypeUint32(input.concurrency) && 1 <= input.concurrency);
+            const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
+            let _errorFactory;
+            return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceParserOptions",
+                        value: input
+                    }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceParserOptions",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(options).concurrency ?? 4);
+    }
+    /**
+     * Lists pinned grammar provenance without loading a language.
+     *
+     * The returned catalog describes acquisition inputs, including checksums and
+     * licenses. It does not imply that every grammar has a certified adapter or
+     * that any grammar has already been downloaded.
+     */
+    async grammars() {
+        return this.assets.list();
+    }
+    /**
+     * Reports admission state and successfully loaded grammar IDs.
+     *
+     * Reading state does not acquire assets or wait for pending parses. The returned
+     * counts describe this pool; the language list records its successful loads.
+     */
+    state() {
+        return {
+            active: this.slots.active,
+            waiting: this.slots.waiting,
+            languages: Array.from(this.loaded).sort((x, y) => x.localeCompare(y, "en")),
+            closed: this.slots.closed,
+        };
+    }
+    /**
+     * Extracts data from a complete syntax tree within a borrowed callback session.
+     *
+     * Syntax errors, missing nodes, and incompatible grammars reject before the
+     * callback can treat a partial tree as a complete declaration inventory.
+     * Callback failures propagate after the tree, parser, and slot are released.
+     *
+     * Callbacks may await work, but must not await another parse or close on this
+     * same pool. Copy names, ranges, and relationships into serializable values;
+     * returning a node, tree, or session would retain already released resources.
+     */
+    async parse(input, closure) {
+        // Capture the string-valued request before queueing. Later caller mutation
+        // must not change grammar selection or text after this request is admitted.
+        input = { ...input };
+        const grammar = EvidenceLanguageRegistry_1.EvidenceLanguageRegistry.select(input.type, input.file);
+        try {
+            await this.slots.acquire();
+        }
+        catch (cause) {
+            throw new EvidenceParserError_1.EvidenceParserError("session-closed", input.file, "This parser runtime is closed. Create a new runtime to parse additional files.", undefined, { cause });
+        }
+        let parser;
+        let tree = null;
+        let session;
+        try {
+            const language = await this.language(grammar.id);
+            parser = new web_tree_sitter_1.Parser();
+            try {
+                parser.setLanguage(language);
+            }
+            catch (cause) {
+                throw new EvidenceParserError_1.EvidenceParserError("grammar-incompatible", input.file, `Grammar ${grammar.id} is not compatible with this runtime. Update the pinned grammar/runtime pair.`, undefined, { cause });
+            }
+            try {
+                tree = parser.parse(input.content);
+            }
+            catch (cause) {
+                throw new EvidenceParserError_1.EvidenceParserError("parse-failed", input.file, "The parser could not analyze this source. Inspect the underlying parser failure.", undefined, { cause });
+            }
+            if (tree === null)
+                throw new EvidenceParserError_1.EvidenceParserError("parse-failed", input.file, "Parsing stopped before producing a tree; this source has no complete inventory.");
+            if (tree.rootNode.hasError) {
+                const cursor = tree.walk();
+                try {
+                    // Descend only through error-bearing branches, including inserted MISSING tokens.
+                    let node = cursor.currentNode;
+                    while (!node.isError && !node.isMissing) {
+                        if (!cursor.gotoFirstChild())
+                            break;
+                        while (!cursor.currentNode.hasError &&
+                            !cursor.currentNode.isMissing) {
+                            if (!cursor.gotoNextSibling())
+                                break;
+                        }
+                        node = cursor.currentNode;
+                    }
+                    throw new EvidenceParserError_1.EvidenceParserError("parse-incomplete", input.file, "The grammar found an ERROR or MISSING node. Correct the source or add support for its syntax before checking coverage.", TreeSitterRange_1.TreeSitterRange.from(node));
+                }
+                finally {
+                    cursor.delete();
+                }
+            }
+            session = new EvidenceParseSession_1.EvidenceParseSession(tree, input.file);
+            return await closure(session);
+        }
+        finally {
+            // Queries borrow the tree, and the tree borrows its parser resources.
+            // Dispose in that order, then free the slot even if extraction threw.
+            if (session !== undefined)
+                session.dispose();
+            if (tree !== null)
+                tree.delete();
+            if (parser !== undefined)
+                parser.delete();
+            this.slots.release();
+        }
+    }
+    /**
+     * Stops admission and waits for accepted parse callbacks to finish.
+     *
+     * Call this outside a parse callback to avoid waiting on the callback itself.
+     * Runtime-local load promises are released afterward; process-wide immutable
+     * grammar data remains reusable by other parser instances.
+     */
+    async close() {
+        await this.slots.close();
+        this.languages.clear();
+    }
+    /**
+     * Reuses or starts the runtime-local load for one pinned grammar ID.
+     *
+     * Sharing the pending promise prevents concurrent parses from downloading and
+     * initializing the same language repeatedly. A failed promise is removed only
+     * when it is still current, allowing a later request to retry without deleting
+     * a newer load that has replaced it.
+     */
+    async language(id) {
+        let pending = this.languages.get(id);
+        if (pending === undefined) {
+            pending = this.load(id);
+            this.languages.set(id, pending);
+        }
+        try {
+            return await pending;
+        }
+        catch (cause) {
+            if (this.languages.get(id) === pending)
+                this.languages.delete(id);
+            throw cause;
+        }
+    }
+    /**
+     * Acquires verified grammar bytes and initializes their Tree-sitter language.
+     *
+     * This is deliberately the only path that adds an ID to `loaded`, so parser
+     * state reports languages usable by this runtime rather than merely requested
+     * or unsuccessfully downloaded assets.
+     */
+    async load(id) {
+        const grammar = await this.assets.grammar(id);
+        const bytes = await this.assets.bytes(grammar);
+        const language = await TreeSitterRuntime_1.TreeSitterRuntime.language(grammar, bytes);
+        this.loaded.add(id);
+        return language;
+    }
+}
+exports.EvidenceParser = EvidenceParser;

package/lib/parsers/EvidenceParserError.d.ts

@@ -0,0 +1,71 @@
+import type { IEvidenceSourceRange } from "../structures/IEvidenceSourceRange";
+import type { EvidenceParserErrorCode } from "../typings/EvidenceParserErrorCode";
+/**
+ * Parser failure preserving its category, affected source, and underlying cause.
+ *
+ * Adapters translate these fields into incomplete-inventory diagnostics, and watch
+ * uses acquisition categories to decide whether timed recovery is appropriate.
+ * A range is available for syntax failures but may be absent before source parsing
+ * begins, such as when grammar acquisition cannot complete.
+ */
+export declare class EvidenceParserError extends Error {
+    /**
+     * Stable parser or acquisition failure category.
+     *
+     * Adapters use it in diagnostic codes and watch uses it to classify retryable
+     * preparation failures.
+     */
+    readonly code: EvidenceParserErrorCode;
+    /**
+     * Source or asset identifier affected by the failed operation.
+     *
+     * This remains useful even when no syntax tree exists to provide a source span.
+     */
+    readonly file: string;
+    /**
+     * Precise source span when the failure can be attributed to parsed syntax.
+     *
+     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     */
+    readonly range?: IEvidenceSourceRange | undefined;
+    /**
+     * Creates a source-qualified error without discarding the original failure cause.
+     *
+     * The message includes the file for ordinary Error consumers; structured callers
+     * can inspect the category and optional span without parsing that message.
+     */
+    constructor(
+    /**
+     * Stable parser or acquisition failure category.
+     *
+     * Adapters use it in diagnostic codes and watch uses it to classify retryable
+     * preparation failures.
+     */
+    code: EvidenceParserErrorCode, 
+    /**
+     * Source or asset identifier affected by the failed operation.
+     *
+     * This remains useful even when no syntax tree exists to provide a source span.
+     */
+    file: string, 
+    /**
+     * Human-readable explanation of the failed parser operation.
+     *
+     * The constructor prefixes this text with `file` for ordinary Error consumers;
+     * structured consumers should use `code`, `file`, and `range` for classification.
+     */
+    message: string, 
+    /**
+     * Precise source span when the failure can be attributed to parsed syntax.
+     *
+     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     */
+    range?: IEvidenceSourceRange | undefined, 
+    /**
+     * Native error metadata retained as this Error's optional cause.
+     *
+     * Omission means the parser has no lower-level exception to preserve, such as a
+     * detected incomplete syntax tree.
+     */
+    options?: ErrorOptions);
+}

package/lib/parsers/EvidenceParserError.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceParserError = void 0;
+/**
+ * Parser failure preserving its category, affected source, and underlying cause.
+ *
+ * Adapters translate these fields into incomplete-inventory diagnostics, and watch
+ * uses acquisition categories to decide whether timed recovery is appropriate.
+ * A range is available for syntax failures but may be absent before source parsing
+ * begins, such as when grammar acquisition cannot complete.
+ */
+class EvidenceParserError extends Error {
+    code;
+    file;
+    range;
+    /**
+     * Creates a source-qualified error without discarding the original failure cause.
+     *
+     * The message includes the file for ordinary Error consumers; structured callers
+     * can inspect the category and optional span without parsing that message.
+     */
+    constructor(
+    /**
+     * Stable parser or acquisition failure category.
+     *
+     * Adapters use it in diagnostic codes and watch uses it to classify retryable
+     * preparation failures.
+     */
+    code, 
+    /**
+     * Source or asset identifier affected by the failed operation.
+     *
+     * This remains useful even when no syntax tree exists to provide a source span.
+     */
+    file, 
+    /**
+     * Human-readable explanation of the failed parser operation.
+     *
+     * The constructor prefixes this text with `file` for ordinary Error consumers;
+     * structured consumers should use `code`, `file`, and `range` for classification.
+     */
+    message, 
+    /**
+     * Precise source span when the failure can be attributed to parsed syntax.
+     *
+     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     */
+    range, 
+    /**
+     * Native error metadata retained as this Error's optional cause.
+     *
+     * Omission means the parser has no lower-level exception to preserve, such as a
+     * detected incomplete syntax tree.
+     */
+    options) {
+        super(`${file}: ${message}`, options);
+        this.code = code;
+        this.file = file;
+        this.range = range;
+        this.name = "EvidenceParserError";
+    }
+}
+exports.EvidenceParserError = EvidenceParserError;

package/lib/parsers/EvidenceTagParser.d.ts

@@ -0,0 +1,56 @@
+import type { IEvidenceDocumentation } from "../structures/IEvidenceDocumentation";
+import type { IEvidenceHost } from "../structures/IEvidenceHost";
+import type { IEvidenceTagParseResult } from "../structures/IEvidenceTagParseResult";
+/**
+ * Coordinates annotation parsing for one documented host.
+ *
+ * Every parse creates fresh continuation, fence, and diagnostic state. The adapter
+ * establishes host attachment and documentation mapping before construction; this
+ * controller preserves those inputs while delegating the grammar to the tag programmer.
+ */
+export declare class EvidenceTagParser {
+    /**
+     * Original source content used to restore annotation positions.
+     *
+     * Documentation stores normalized text, while diagnostics must point into this
+     * complete host source through the documentation's retained offset mapping.
+     */
+    private readonly content;
+    /**
+     * Adapter-established attachment and semantic identity of the documented host.
+     *
+     * The tag programmer uses this host for statements and diagnostics. It is copied
+     * at construction so a caller cannot redirect parsed annotations by later mutation.
+     */
+    private readonly host;
+    /**
+     * Mapped documentation accepted for this host by its adapter.
+     *
+     * Its tag boundaries and withdrawal policy define what annotation syntax is valid;
+     * the copy keeps a parse operation tied to the attachment it was created for.
+     */
+    private readonly documentation;
+    /**
+     * Captures one adapter-established host and its mapped documentation.
+     *
+     * Callers supply the full source solely for source-coordinate conversion. The
+     * constructor does not parse tags, allowing adapters to build all host records
+     * before the independent parsing phase begins.
+     */
+    constructor(content: string, host: IEvidenceHost, documentation: IEvidenceDocumentation);
+    /**
+     * Parses the captured documentation into statements, withdrawals, and diagnostics.
+     *
+     * Mutable continuation and code-fence state is allocated per call. Repeated calls
+     * therefore produce independent results and cannot carry an unfinished tag from
+     * one extraction cycle into another.
+     */
+    parse(): IEvidenceTagParseResult;
+    /**
+     * Parses one adapter-mapped documentation attachment without retaining a controller.
+     *
+     * This convenience entry point has the same snapshot and isolation guarantees as
+     * constructing a parser and calling `parse`, and is suitable for one-off adapter work.
+     */
+    static parse(content: string, host: IEvidenceHost, documentation: IEvidenceDocumentation): IEvidenceTagParseResult;
+}

package/lib/parsers/EvidenceTagParser.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceTagParser = void 0;
+const SourceText_1 = require("../internal/SourceText");
+const EvidenceTagProgrammer_1 = require("../programmers/EvidenceTagProgrammer");
+/**
+ * Coordinates annotation parsing for one documented host.
+ *
+ * Every parse creates fresh continuation, fence, and diagnostic state. The adapter
+ * establishes host attachment and documentation mapping before construction; this
+ * controller preserves those inputs while delegating the grammar to the tag programmer.
+ */
+class EvidenceTagParser {
+    /**
+     * Original source content used to restore annotation positions.
+     *
+     * Documentation stores normalized text, while diagnostics must point into this
+     * complete host source through the documentation's retained offset mapping.
+     */
+    content;
+    /**
+     * Adapter-established attachment and semantic identity of the documented host.
+     *
+     * The tag programmer uses this host for statements and diagnostics. It is copied
+     * at construction so a caller cannot redirect parsed annotations by later mutation.
+     */
+    host;
+    /**
+     * Mapped documentation accepted for this host by its adapter.
+     *
+     * Its tag boundaries and withdrawal policy define what annotation syntax is valid;
+     * the copy keeps a parse operation tied to the attachment it was created for.
+     */
+    documentation;
+    /**
+     * Captures one adapter-established host and its mapped documentation.
+     *
+     * Callers supply the full source solely for source-coordinate conversion. The
+     * constructor does not parse tags, allowing adapters to build all host records
+     * before the independent parsing phase begins.
+     */
+    constructor(content, host, documentation) {
+        this.content = content;
+        this.host = structuredClone(host);
+        this.documentation = structuredClone(documentation);
+    }
+    /**
+     * Parses the captured documentation into statements, withdrawals, and diagnostics.
+     *
+     * Mutable continuation and code-fence state is allocated per call. Repeated calls
+     * therefore produce independent results and cannot carry an unfinished tag from
+     * one extraction cycle into another.
+     */
+    parse() {
+        const context = {
+            source: new SourceText_1.SourceText(this.content),
+            host: this.host,
+            documentation: this.documentation,
+            result: {
+                declarations: [],
+                reviews: [],
+                withdrawals: [],
+                diagnostics: [],
+            },
+            pending: undefined,
+            fence: "",
+            fenceLength: 0,
+        };
+        return EvidenceTagProgrammer_1.EvidenceTagProgrammer.parse(context);
+    }
+    /**
+     * Parses one adapter-mapped documentation attachment without retaining a controller.
+     *
+     * This convenience entry point has the same snapshot and isolation guarantees as
+     * constructing a parser and calling `parse`, and is suitable for one-off adapter work.
+     */
+    static parse(content, host, documentation) {
+        return new EvidenceTagParser(content, host, documentation).parse();
+    }
+}
+exports.EvidenceTagParser = EvidenceTagParser;

package/lib/programmers/EvidenceCheckProgrammer.d.ts

@@ -0,0 +1,36 @@
+import type { IEvidenceMaterializedClaim } from "../internal/IEvidenceMaterializedClaim";
+import type { IEvidenceCheckAnalysis } from "../structures/IEvidenceCheckAnalysis";
+import type { IEvidenceConfigPlan } from "../structures/IEvidenceConfigPlan";
+import type { IEvidenceCheckContext } from "../contexts/IEvidenceCheckContext";
+/**
+ * Turns a validated check plan into inventories, graph input, and a command report.
+ *
+ * This namespace is the orchestration boundary between configuration and graph
+ * evaluation. It keeps every configured reference independent, so the same
+ * population can appear in several obligations without sharing a resolution or
+ * silently discharging coverage in another claim.
+ *
+ * @example
+ *   const claims = await EvidenceCheckProgrammer.materialize(plan);
+ *   const analysis = await EvidenceCheckProgrammer.evaluate({ plan, claims });
+ */
+export declare namespace EvidenceCheckProgrammer {
+    /**
+     * Materializes every active claim and the reference populations it owns.
+     *
+     * The returned array retains the configuration-plan order because evaluation
+     * and reporting use positions as stable claim coordinates. Loading is allowed
+     * to run concurrently, but each materialized reference remains attached to
+     * exactly the claim entry that declared it.
+     */
+    function materialize(plan: IEvidenceConfigPlan): Promise<IEvidenceMaterializedClaim[]>;
+    /**
+     * Prepares graph input and evaluates the checker result for one execution.
+     *
+     * Preparation resolves annotations against each independent reference boundary
+     * before {@link EvidenceGraph.evaluate} applies coverage policy. The returned
+     * analysis deliberately retains both graph input and graph output so query
+     * commands can explain the result without rebuilding or reloading inventories.
+     */
+    function evaluate(context: IEvidenceCheckContext): Promise<IEvidenceCheckAnalysis>;
+}