@timiagama/ecr 0.0.1 → 0.1.0

package/dist/per-document-visitor.d.ts

@@ -0,0 +1,510 @@
+/**
+ * Per-Document Visitor
+ *
+ * Orchestrates all four ECR rules (ECR101--ECR104) over a single Markdown
+ * document, producing a composite {@link LintResult}.
+ *
+ * This is the integration layer that:
+ *   1. Parses Markdown text into an AST using `unified` + `remark-parse`
+ *   2. Walks the AST and dispatches nodes to the appropriate rules
+ *   3. Manages the rule initialisation dependency chain:
+ *      - ECR101 must complete before ECR102/ECR103 can start
+ *      - ECR103 must complete before ECR104 can start (to provide declared DocIDs)
+ *      - If ECR101 fails, downstream rules are skipped entirely
+ *   4. Filters text nodes: excludes those inside `code`, `inlineCode`, `html`,
+ *      or link URL contexts before feeding to ECR104
+ *   5. Tracks the current section context (heading identifier) for ECR104
+ *   6. Feeds list items within the References section to ECR103
+ *   7. Finalises all rules and assembles the composite {@link LintResult}
+ *
+ * Spec references:
+ *   - 1#8   -- Visitor and State Model
+ *   - 1#11.1 -- Pass 1: Per-Document Parse, Validate, Extract
+ *   - 1#9.3 -- Document Identity Rule [ECR101]
+ *   - 1#9.4 -- Section Structure Rules [ECR102]
+ *   - 1#9.5 -- Inline Reference Rules [ECR104]
+ *   - 1#9.6 -- References Section Rules [ECR103]
+ *   - 1#10.2 -- LintResult
+ *   - 1#10.4 -- ExtractedDocument
+ */
+import type { LintResult } from './types.js';
+/**
+ * Configuration options for constructing a {@link PerDocumentVisitor} instance.
+ */
+export interface PerDocumentVisitorOptions {
+    /**
+     * The opaque, host-provided URI identifying the document being validated.
+     *
+     * Passed through to all rules and echoed in the {@link LintResult.input} field.
+     */
+    readonly uri: string;
+    /**
+     * Optional version tag for the document instance.
+     *
+     * Passed through to the {@link LintResult.input} field. When omitted, the
+     * resulting {@link LintInput.version} will be `undefined`.
+     */
+    readonly version?: number;
+}
+/** Rule identifier reported when a document cannot be parsed at all. */
+export declare const UNPARSABLE_DOCUMENT_RULE_ID: string;
+/** The `data.cause` of that diagnostic. */
+export declare const UNPARSABLE_DOCUMENT_CAUSE: string;
+/**
+ * MDAST node types whose descendant text nodes must be excluded from
+ * ECR104 inline reference detection.
+ *
+ * Per 1#9.5, text nodes inside code blocks, inline code, and HTML
+ * elements are not valid candidates for inline reference detection.
+ */
+export declare const EXCLUDED_ANCESTOR_NODE_TYPES: ReadonlySet<string>;
+/**
+ * Orchestrates all four ECR rules (ECR101--ECR104) over a single Markdown
+ * document and produces a composite {@link LintResult}.
+ *
+ * The visitor is stateless between calls to {@link lint}. Each invocation
+ * produces a fresh result with no side effects on the visitor instance.
+ *
+ * The visitor creates its own {@link IdentifierGrammar} instance internally
+ * and manages the rule initialisation dependency chain:
+ * - ECR101 (Document Identity) runs first on all headings
+ * - If ECR101 produces a valid DocID, ECR102 (Section Hierarchy) and
+ *   ECR103 (References Section) are initialised and fed their respective nodes
+ * - After ECR103 finalises, the set of declared DocIDs is extracted and
+ *   used to initialise ECR104 (Inline Reference)
+ * - If ECR101 fails (no valid DocID), the result is returned early with
+ *   `ok=false` and no `extracted` field
+ *
+ * Usage:
+ * ```ts
+ * const visitor = new PerDocumentVisitor({
+ *   uri: 'file:///docs/3.1.md',
+ *   version: 1,
+ * });
+ *
+ * const result: LintResult = visitor.lint('# 3.1 - My Document\n\n## References\n- 8.1 - ...');
+ * ```
+ *
+ * @example
+ * ```ts
+ * const visitor = new PerDocumentVisitor({ uri: 'file:///docs/5.1.md' });
+ * const result: LintResult = visitor.lint(markdownText);
+ *
+ * if (result.ok) {
+ *   console.log('Document is valid:', result.extracted?.docId);
+ * } else {
+ *   console.log('Diagnostics:', result.diagnostics);
+ * }
+ * ```
+ */
+export declare class PerDocumentVisitor {
+    /**
+     * The opaque, host-provided URI identifying the document being validated.
+     */
+    private readonly uri;
+    /**
+     * Optional version tag for the document instance.
+     */
+    private readonly version;
+    /**
+     * The {@link IdentifierGrammar} instance shared across all rules
+     * within a single visitor. Created once during construction.
+     */
+    private readonly grammar;
+    /**
+     * Constructs a new Per-Document Visitor.
+     *
+     * Creates an internal {@link IdentifierGrammar} instance for use
+     * across all rule evaluations performed by this visitor.
+     *
+     * @param options - Configuration including the document URI and optional version
+     */
+    constructor(options: PerDocumentVisitorOptions);
+    /**
+     * Lints a single Markdown document and produces a composite {@link LintResult}.
+     *
+     * Each call is stateless: the visitor creates fresh rule instances,
+     * parses the Markdown text into an AST, walks the AST to feed nodes
+     * to the appropriate rules, finalises all rules, and assembles the result.
+     *
+     * The orchestration proceeds in phases:
+     * 1. Parse the Markdown text into an MDAST {@link MdastRoot} node
+     * 2. First pass: walk headings and list items for ECR101, ECR102, ECR103
+     * 3. If ECR101 fails (no valid DocID), return early with `ok=false`
+     * 4. Second pass: walk text nodes for ECR104 (with ancestor filtering
+     *    and section context tracking)
+     * 5. Assemble the composite {@link LintResult} from all rule results
+     *
+     * @param markdownText - The raw Markdown text of the document to lint
+     * @returns The composite lint result including diagnostics and, when a valid
+     *          DocID is recovered, extracted structural artefacts
+     */
+    lint(markdownText: string): LintResult;
+    /**
+     * Parses raw Markdown text into an MDAST {@link MdastRoot} node.
+     *
+     * Uses `unified` with `remark-parse` to produce a standards-compliant
+     * MDAST tree with positional metadata attached to all nodes.
+     *
+     * The `unified().use(remarkParse).parse()` call returns a type that
+     * cannot be directly assigned to our local {@link MdastRoot} interface
+     * because `mdast` types are not importable as a module specifier in this
+     * project. The cast via `unknown` is safe because `remark-parse` always
+     * produces an MDAST Root node at runtime.
+     *
+     * @param markdownText - The raw Markdown text to parse
+     * @returns The parsed MDAST root node
+     */
+    private parseMarkdown;
+    /**
+     * Reports a document the parser could not read.
+     *
+     * The parser walks a document's structure by recursion, inside a package
+     * this project does not control, so a deeply nested link label or image
+     * description can end the parse with a stack overflow. That must be one
+     * document's error, reported like any other, and never a crash that stops
+     * a corpus part way and leaves the rest unvalidated.
+     *
+     * @param error - What the parser threw
+     * @returns A failing result carrying one error diagnostic
+     */
+    private reportUnparsable;
+    /**
+     * Executes the first AST traversal pass: headings, sections, and references.
+     *
+     * This pass walks the AST in document order and:
+     * - Feeds every heading node to ECR101 (`DocumentIdentityRule.evaluateHeading`)
+     * - Finalises ECR101 to determine whether a valid DocID was recovered
+     * - If a valid DocID is recovered:
+     *   - Registers the root H1 heading with ECR102
+     *     (`SectionHierarchyRule.registerRootHeading`)
+     *   - Feeds headings with depth \>= 2 to ECR102
+     *     (`SectionHierarchyRule.evaluateHeading`)
+     *   - Feeds all headings to ECR103
+     *     (`ReferencesSectionRule.evaluateHeading`)
+     *   - Feeds list items within the References section to ECR103
+     *     (`ReferencesSectionRule.evaluateListItem`)
+     *   - Finalises ECR102 and ECR103
+     * - If no valid DocID is recovered, ECR102 and ECR103 are skipped
+     *
+     * The pass is structured so that all heading nodes are collected first
+     * for ECR101, then the collected headings are replayed for ECR102 and ECR103.
+     *
+     * @param root - The parsed MDAST root node
+     * @param sourceText - The document's raw Markdown, for the heading source-form check of 1#9.11
+     * @returns The intermediate result from the headings and references pass
+     */
+    private executeHeadingsAndReferencesPass;
+    /**
+     * Collects all heading nodes from the AST into the provided array.
+     *
+     * Walks the AST depth-first in document order, extracting
+     * {@link HeadingNodeData} from every node with `type === 'heading'`.
+     *
+     * @param node - The root of the walk
+     * @param headings - The accumulator array for collected heading data
+     */
+    private collectHeadings;
+    /**
+     * Reads a node's plain text: what a reader sees, with the formatting gone.
+     *
+     * @param node - The node to read
+     * @returns Its text, and its descendants' text, in order
+     */
+    private static showNodeText;
+    /**
+     * Puts a node's children on a walk's stack so that they come off it in
+     * document order.
+     *
+     * Every walk over a document's nodes keeps its own stack rather than
+     * calling itself, because nesting in Markdown costs the author almost
+     * nothing: a few thousand nested blockquotes, or nested bold spans, fit in
+     * a few kilobytes, and recursion over them exhausts the call stack and
+     * takes the process with it. A stack on the heap has no such limit.
+     *
+     * @param node - The node whose children are to be walked
+     * @param pending - The stack to push onto, from which nodes are taken with `pop`
+     */
+    private static pushChildren;
+    /**
+     * Finds the References section and feeds its placement and entries to ECR103.
+     *
+     * The `## References` heading is looked for anywhere in the tree, not only
+     * among the root's children. A section nested in a blockquote or a list
+     * item used to be passed over, so its entries were silently discarded and
+     * the document reported as having an empty References section. It is now
+     * found, reported as misplaced (1#9.11 rule 3), and its entries still read.
+     *
+     * The entries are the items of the list that immediately follows the
+     * heading, or of a list that opens the container immediately following it
+     * -- which is also a placement violation.
+     *
+     * @param root - The parsed MDAST root node
+     * @param referencesSectionRule - The ECR103 rule instance to feed
+     */
+    private feedListItemsToReferencesRule;
+    /**
+     * Finds the list holding the References entries, given the node after the
+     * heading: that node itself, or a list opening the container it is, at any
+     * depth of nesting.
+     *
+     * Looking one container deep lost `> > - 8.1 - …`: the list was never
+     * found, so its entries were discarded and the section reported as empty.
+     *
+     * @param next - The node immediately following the `## References` heading
+     * @returns The entries' list, or `undefined` when there is none
+     */
+    private findReferencesList;
+    /**
+     * Finds the first `## References` heading in document order, at any depth.
+     *
+     * @param node - The node to search from
+     * @returns The heading and its position among its siblings, or `undefined`
+     */
+    private findReferencesSection;
+    /**
+     * Executes the second AST traversal pass: inline reference detection.
+     *
+     * This pass walks the AST in document order using a custom recursive
+     * traversal that tracks ancestor node types and:
+     * - Tracks the current section context (the most recently encountered
+     *   heading identifier), starting with the DocID before any H2 heading
+     * - For each text node encountered, checks whether the node's ancestor
+     *   chain includes any excluded node types (`code`, `inlineCode`, `html`)
+     * - Text nodes whose ancestors include excluded types are skipped
+     * - Valid text nodes are fed to ECR104
+     *   (`InlineReferenceRule.evaluateTextNode`) with the current
+     *   section context
+     * - After traversal, ECR104 is finalised
+     *
+     * @param root - The parsed MDAST root node
+     * @param docId - The document's established DocID
+     * @param declaredDocIds - The set of DocIDs declared in the References section
+     * @param sourceText - The document's raw Markdown, for the source-form checks of 1#9.11
+     * @returns The intermediate result from the inline references pass
+     */
+    private executeInlineReferencesPass;
+    /**
+     * Walks the AST to find inline runs for ECR104, tracking whether an
+     * excluded ancestor encloses the node and updating section context when
+     * headings are encountered.
+     *
+     * A paragraph is handed to ECR104 whole, as one inline run, because a
+     * citation is recognised in the text a reader sees and not one parsed text
+     * node at a time (1#9.5 rule 1). Its children are not walked separately.
+     *
+     * A hand-written depth-first, pre-order walk over an explicit stack: document
+     * order decides which section each run belongs to, and see
+     * {@link PerDocumentVisitor.pushChildren} for why the stack is not the call
+     * stack. Exclusion is carried down as one flag, because a node is excluded
+     * exactly when some ancestor's type is, so nothing is gained by keeping the
+     * ancestors themselves.
+     *
+     * @param root - The root of the walk
+     * @param sectionContext - Mutable wrapper holding the current section context
+     * @param inlineReferenceRule - The ECR104 rule instance to feed runs to
+     */
+    private walkNodesForInlineReferences;
+    /**
+     * Puts a node's children on the inline walk's stack, in document order,
+     * noting whether an excluded ancestor now encloses them.
+     *
+     * @param node - The node whose children are to be walked
+     * @param excluded - Whether an excluded ancestor already encloses the node
+     * @param pending - The stack to push onto
+     */
+    private static pushInlineWalkChildren;
+    /**
+     * Flattens one inline node into the segments a reader sees, in order.
+     *
+     * Text becomes a `text` segment carrying its position, and inline code a
+     * `code` segment. Formatting contributes its contents, each segment noting
+     * the spans around it. A hard break, an image, and a `<br>` tag become a
+     * `break` of one space, because a reader sees the words either side of them
+     * as separate. Any other inline HTML -- a comment, or a tag such as
+     * `<span>` -- contributes nothing, because it separates nothing:
+     * `60<span>s</span>` reads as `60s`.
+     *
+     * @param node - An inline node
+     * @param wrappers - Types of the formatting spans enclosing it, outermost first
+     * @param segments - Accumulator the segments are appended to
+     */
+    private collectInlineSegments;
+    /**
+     * Turns one inline node into segments, or puts its children on the stack
+     * to be turned into segments in their turn.
+     *
+     * @param entry - The node and the formatting spans enclosing it
+     * @param segments - Accumulator the segments are appended to
+     * @param pending - The walk's stack, which children are pushed onto in document order
+     */
+    private collectInlineSegment;
+    /**
+     * Determines the current section context identifier for a given heading.
+     *
+     * The section context is the identifier (DocID or SectionID) of the most
+     * recently encountered numbered heading. Before any H2 heading, the context
+     * is the DocID. After an H2 or deeper heading, the context is the
+     * SectionID of that heading.
+     *
+     * This method extracts the identifier from the heading text using the
+     * grammar's separator convention. If the heading text does not contain
+     * a valid identifier, the previous context is retained.
+     *
+     * @param headingText - The plain text content of the heading node
+     * @param headingDepth - The Markdown heading depth (1--6)
+     * @param currentContext - The current section context before this heading
+     * @returns The updated section context identifier
+     */
+    private determineSectionContext;
+    /**
+     * Determines whether a heading is the `## References` structural heading.
+     *
+     * The `## References` heading is owned by ECR103 and should not be
+     * evaluated by ECR102 (Section Hierarchy), because it is not a numbered
+     * section heading and would fail SectionID parsing.
+     *
+     * Per 1#9.6, the References heading is identified by depth === 2
+     * and text content exactly equal to `"References"`.
+     *
+     * @param headingData - The heading node data to check
+     * @returns `true` if the heading is the `## References` heading, `false` otherwise
+     */
+    private tellReferencesHeading;
+    /**
+     * Extracts the plain text content from a list item AST node.
+     *
+     * Gathers the text of the list item's child nodes into a single plain text
+     * string suitable for feeding to ECR103.
+     *
+     * @param listItemNode - The MDAST list item node to extract text from
+     * @returns The extracted {@link ListItemNodeData} with text and optional range
+     */
+    private extractListItemNodeData;
+    /**
+     * Classifies a literal node for tracing its text back to the source.
+     *
+     * @param type - The node's MDAST type
+     * @returns `text` for a text node, `code` for inline code, `other` otherwise
+     */
+    private static showSegmentKind;
+    /**
+     * Splits a list item's text into the parsed nodes it comes from.
+     *
+     * Follows `mdast-util-to-string` exactly -- a node's `value`, else an
+     * image's `alt`, else its children in order -- so that joining the
+     * segments reproduces the entry text the rule parses, and an offset in that
+     * text identifies the node, and so the source, it came from.
+     *
+     * @param node - A node within the list item
+     * @param segments - Accumulator the segments are appended to
+     */
+    private collectListItemSegments;
+    /**
+     * Extracts heading node data from an MDAST heading node.
+     *
+     * Reads the plain text content with {@link PerDocumentVisitor.showNodeText}
+     * and maps the MDAST position to a {@link HeadingNodeData} structure
+     * suitable for consumption by ECR101, ECR102, and ECR103.
+     *
+     * @param headingNode - The MDAST heading node to extract data from
+     * @returns The extracted {@link HeadingNodeData} with depth, text, and optional range
+     */
+    private extractHeadingNodeData;
+    /**
+     * Extracts text node data from an MDAST text node.
+     *
+     * Maps the MDAST text node's value and position to a {@link TextNodeData}
+     * structure suitable for consumption by ECR104.
+     *
+     * @param textNode - The MDAST text node to extract data from
+     * @returns The extracted {@link TextNodeData} with text and optional range
+     */
+    private extractTextNodeData;
+    /**
+     * Extracts the set of declared DocIDs from a completed ECR103 result.
+     *
+     * Iterates over the extracted {@link ReferenceEdge} artefacts and
+     * collects the `toDocId` field from each edge into a `ReadonlySet<DocID>`.
+     * This set is used to initialise ECR104 for undeclared reference detection.
+     *
+     * @param references - The extracted reference edges from ECR103
+     * @returns The set of declared DocIDs
+     */
+    private extractDeclaredDocIds;
+    /**
+     * Maps an MDAST position to a {@link PositionRange}, if available.
+     *
+     * MDAST positions use 1-based lines and 1-based columns, while
+     * {@link PositionRange} uses 0-based lines and 0-based characters.
+     * This method performs the conversion.
+     *
+     * @param mdastPosition - The MDAST position object, or `undefined` if
+     *                         positional metadata is not available
+     * @returns The mapped position range, or `undefined` if no position is available
+     */
+    private mapPosition;
+    /**
+     * Assembles the composite {@link LintResult} from individual rule results.
+     *
+     * Aggregates diagnostics from all rules, determines the `ok` status
+     * (true when no error-severity diagnostics are present), and constructs
+     * the {@link ExtractedDocument} when a valid DocID was recovered.
+     *
+     * @param identityResult - The result from ECR101
+     * @param sectionsResult - The result from ECR102 (undefined if ECR101 failed)
+     * @param referencesResult - The result from ECR103 (undefined if ECR101 failed)
+     * @param inlineResult - The result from ECR104 (undefined if ECR101 failed)
+     * @returns The composite lint result
+     */
+    private assembleLintResult;
+    /**
+     * Aggregates diagnostics from all rule results into a single array.
+     *
+     * Collects diagnostics from ECR101, ECR102, ECR103, and ECR104 in that
+     * order. Rules that did not run (undefined results) contribute no
+     * diagnostics.
+     *
+     * @param identityResult - The result from ECR101
+     * @param sectionsResult - The result from ECR102 (undefined if ECR101 failed)
+     * @param referencesResult - The result from ECR103 (undefined if ECR101 failed)
+     * @param inlineResult - The result from ECR104 (undefined if ECR101 failed)
+     * @returns The aggregated array of all diagnostics
+     */
+    private aggregateDiagnostics;
+    /**
+     * Constructs the {@link LintInput} descriptor for the result.
+     *
+     * Echoes the visitor's URI and optional version into the standard
+     * input descriptor shape.
+     *
+     * @returns The lint input descriptor
+     */
+    private buildLintInput;
+    /**
+     * Determines the composite `ok` status from an aggregated diagnostics array.
+     *
+     * The result is `ok` (true) when no diagnostics have severity `"error"`.
+     * Any error-severity diagnostic causes the result to be not-ok (false).
+     *
+     * @param diagnostics - The full array of aggregated diagnostics from all rules
+     * @returns `true` if no error diagnostics are present, `false` otherwise
+     */
+    private tellAllDiagnosticsPassable;
+    /**
+     * Constructs the {@link ExtractedDocument} from individual rule extraction
+     * results.
+     *
+     * Assembles the document identity (DocID and title), section nodes,
+     * reference edges, and inline reference edges into the canonical
+     * extracted document shape.
+     *
+     * @param identity - The document identity from ECR101
+     * @param sections - The section nodes from ECR102
+     * @param references - The reference edges from ECR103
+     * @param inlineReferences - The inline reference edges from ECR104
+     * @returns The assembled extracted document
+     */
+    private buildExtractedDocument;
+}
+//# sourceMappingURL=per-document-visitor.d.ts.map

package/dist/per-document-visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-document-visitor.d.ts","sourceRoot":"","sources":["../src/per-document-visitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAaH,OAAO,KAAK,EAMV,UAAU,EAKX,MAAM,YAAY,CAAC;AA6EpB;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AA6CD,wEAAwE;AACxE,eAAO,MAAM,2BAA2B,EAAE,MAA8B,CAAC;AAEzE,2CAA2C;AAC3C,eAAO,MAAM,yBAAyB,EAAE,MAA8B,CAAC;AASvE;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,MAAM,CAI3D,CAAC;AAiGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C;;;;;;;OAOG;gBACgB,OAAO,EAAE,yBAAyB;IAMrD;;;;;;;;;;;;;;;;;;OAkBG;IACI,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU;IAqD7C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAAO,CAAC,gCAAgC;IA4ExC;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAgC3B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAgB3B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,6BAA6B;IA8BrC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,2BAA2B;IAkCnC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,4BAA4B;IAyDpC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAsBrC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IA6B/B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IAoB/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAQ9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,uBAAuB;IAmC/B;;;;;;;;;OASG;IACH,OAAO,CAAC,sBAAsB;IAoB9B;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IAkB3B;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,WAAW;IAyBnB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,kBAAkB;IAiD1B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,oBAAoB;IAiC5B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAStB;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IAQlC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;CAgB/B"}