@redocly/recheck 0.1.0 → 0.2.0

package/dist/parser/markdoc/pairing.js

@@ -0,0 +1,94 @@
+/**
+ * A "nothing was paired" result for callers that must still supply a
+ * `MarkdocPairing` but have no reason to run the pass -- the runner uses it when
+ * the Markdoc flag is on but no active rule can read the buckets anyway. A
+ * factory rather than a shared constant, because the buckets are mutable arrays
+ * and one shared instance would let an accidental push leak across files.
+ */
+export function emptyMarkdocPairing() {
+    return { pairs: [], unclosed: [], orphaned: [], crossed: [], voidMissingSlash: [] };
+}
+// Kinds that never enter the pairing stack: annotation, variable, and function
+// spans carry no tag name at all, a self-closing tag (`{% x /%}`) is already
+// complete on its own, and a malformed span is left inert so it cannot disturb
+// the pairing of the well-formed tags around it (the syntax-level rule owns
+// reporting it).
+const NEVER_PAIRED_KINDS = new Set([
+    'annotation',
+    'variable',
+    'function',
+    'tag-self-closing',
+    'malformed',
+]);
+/** The tag's own name, from its synthesized `markdocTagName` child (absent
+ * only for the kinds already filtered out above, where it's `null`). */
+function tagName(token) {
+    const nameChild = token.children.find((child) => child.type === 'markdocTagName');
+    return nameChild ? nameChild.text : null;
+}
+/**
+ * Computes open/close pairing for a document's `markdocTag` tokens with a single
+ * stack walk in document order. The filtered list is sorted by position rather
+ * than trusting whatever order `tree.flat` happens to be in, since
+ * `structureMarkdocTags` (structure.ts) appends its own synthesized children to
+ * the end of that same array.
+ *
+ * Deliberate divergence from upstream Markdoc, which tests a close only against
+ * the immediate top of its stack and never searches deeper: for
+ * `{% a %}{% b %}{% /a %}{% /b %}` upstream reports a missing-closing plus a
+ * missing-opening and lets `a`'s node swallow everything to EOF, while this pass
+ * searches the whole stack innermost-first and reports both pairs as `crossed`.
+ * "These two pairs are interleaved" is the more actionable diagnostic, and a
+ * crossing can never silently land in `pairs`, so no error upstream reports is
+ * lost. The cost is that consumers relying on pair ranges see a narrower range
+ * for a crossed `open` than upstream's AST would give.
+ */
+export function computeMarkdocPairing(tree, options = {}) {
+    const selfClosingTags = options.selfClosingTags ?? new Set();
+    const tags = tree.flat
+        .filter((token) => token.type === 'markdocTag')
+        .sort((a, b) => a.startLine - b.startLine || a.startColumn - b.startColumn);
+    const stack = [];
+    const pairs = [];
+    const crossed = [];
+    const orphaned = [];
+    for (const token of tags) {
+        const kind = token.markdocKind;
+        if (kind === undefined || NEVER_PAIRED_KINDS.has(kind))
+            continue;
+        const name = tagName(token);
+        if (name === null)
+            continue; // defensive only: every tag-open/tag-close carries a name
+        if (kind === 'tag-open') {
+            stack.push({ token, name, depth: stack.length, crossed: false });
+            continue;
+        }
+        // kind === 'tag-close': innermost-first search for the nearest same-name open.
+        let matchIndex = -1;
+        for (let i = stack.length - 1; i >= 0; i--) {
+            if (stack[i].name === name) {
+                matchIndex = i;
+                break;
+            }
+        }
+        if (matchIndex === -1) {
+            orphaned.push(token);
+            continue;
+        }
+        const jumpedOver = matchIndex !== stack.length - 1;
+        if (jumpedOver) {
+            for (let i = matchIndex + 1; i < stack.length; i++)
+                stack[i].crossed = true;
+        }
+        const [matched] = stack.splice(matchIndex, 1);
+        const pair = { open: matched.token, close: token, depth: matched.depth };
+        (jumpedOver || matched.crossed ? crossed : pairs).push(pair);
+    }
+    const unclosed = [];
+    const voidMissingSlash = [];
+    for (const entry of stack) {
+        (selfClosingTags.has(entry.name) ? voidMissingSlash : unclosed).push(entry.token);
+    }
+    return { pairs, unclosed, orphaned, crossed, voidMissingSlash };
+}
+//# sourceMappingURL=pairing.js.map

package/dist/parser/markdoc/pairing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.js","sourceRoot":"","sources":["../../../src/parser/markdoc/pairing.ts"],"names":[],"mappings":"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"}

package/dist/parser/markdoc/schema.d.ts

@@ -0,0 +1,85 @@
+/**
+ * One attribute's statically-checkable facets. `type` is limited to the three
+ * JSON primitives recheck can compare a parsed literal against; anything richer
+ * upstream (objects, arrays, union types, custom attribute classes) has no
+ * faithful representative here and gets `dynamic: true` instead.
+ */
+export interface MarkdocAttributeSchema {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    default?: string | number | boolean;
+    /** Markdoc's `matches` array, renamed for recheck's own vocabulary. */
+    enum?: readonly string[];
+    /**
+     * Set when the upstream attribute's type isn't one of the three JSON
+     * primitives, or when the tag's schema carries a `validate()` function.
+     * Recheck's value-shape checks (type and enum) skip such an attribute rather
+     * than guess at business logic they cannot run. `required` is deliberately not
+     * skipped: upstream enforces it purely by presence, independently of `type`,
+     * `matches`, and `validate()`, even for a custom-class-typed attribute, so
+     * `markdoc-attributes` checks it unconditionally. The attribute's name is known
+     * either way, so unknown-attribute checks are unaffected.
+     */
+    dynamic?: boolean;
+}
+export interface MarkdocTagSchema {
+    selfClosing?: boolean;
+    attributes?: Record<string, MarkdocAttributeSchema>;
+}
+export interface MarkdocSchema {
+    tags: Record<string, MarkdocTagSchema>;
+}
+/**
+ * The object form of the `markdoc` config key. `schema` is required here: the
+ * boolean shorthand `true` unambiguously means `{ schema: 'realm' }`, but an
+ * object with `schema` omitted has no default this format defines, so
+ * `config/schema.ts` rejects it rather than guessing.
+ */
+export interface MarkdocUserConfig {
+    schema: 'realm' | false;
+    extend?: {
+        tags?: Record<string, MarkdocTagSchema>;
+        tagsFile?: string;
+    };
+}
+/**
+ * The already-loaded view of `extend` that `config/validate.ts` builds after
+ * reading and shape-checking `tagsFile` (if any): `fileTags` is that file's
+ * tags, `tags` is the config's own inline `extend.tags`. Kept as two separate
+ * fields, not pre-merged, so `mergeExtend` alone owns the precedence order.
+ */
+export interface ResolvedExtend {
+    fileTags?: Record<string, MarkdocTagSchema>;
+    tags?: Record<string, MarkdocTagSchema>;
+}
+/**
+ * Normalizes the raw `markdoc` config value (boolean shorthand or object form)
+ * into `{ enabled, schema }`. It is called from `config/validate.ts` after AJV
+ * structural validation, but the check order there means it still sees the raw
+ * value when validation failed, so it must never throw on a malformed shape
+ * (`{ schema: 'bogus' }`, a bare string): anything unrecognized normalizes to
+ * disabled.
+ *
+ * `schema: false` deliberately is not "fully off". Parsing and pairing still
+ * run, and only the schema-dependent rules (unknown tag, and the
+ * unknown/required/enum attribute checks) go inert for lack of anything to check
+ * against. `extend` alongside `schema: false` is accepted structurally but has
+ * no effect, since there is no base to merge over.
+ *
+ * `resolvedExtend`, when passed, is the caller's already-loaded view of
+ * `extend` (`tagsFile` read and shape-checked, see config/validate.ts) and
+ * takes over from `raw.extend` entirely -- this module never reads a
+ * `tagsFile` itself, so a caller that resolved one has strictly more
+ * information than `raw.extend` alone.
+ */
+export declare function resolveMarkdocConfig(raw: boolean | MarkdocUserConfig | undefined, resolvedExtend?: ResolvedExtend): {
+    enabled: boolean;
+    schema: MarkdocSchema | null;
+};
+/**
+ * Tag names a schema declares self-closing, in the plain `Set<string>` shape
+ * `pairing.ts` consumes so the pairing pass depends on none of this module's
+ * types.
+ */
+export declare function selfClosingTagNames(schema: MarkdocSchema): ReadonlySet<string>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/parser/markdoc/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/schema.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACpC,uEAAuE;IACvE,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,GAAG,KAAK,CAAC;IAOxB,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACzC;AAsBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,EAC5C,cAAc,CAAC,EAAE,cAAc,GAC9B;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CAC9B,CAoBA;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC,MAAM,CAAC,CAM9E"}

package/dist/parser/markdoc/schema.js

@@ -0,0 +1,86 @@
+// Recheck's own YAML-serializable Markdoc schema format, deliberately not
+// Markdoc's own `Config['tags']` shape: class-typed attributes and `validate()`
+// functions cannot round-trip through a user's recheck.yaml or be diffed and
+// committed as plain data. This module holds the types, the resolver that turns
+// the boolean or object config form into `{ enabled, schema }`, and the one
+// place that reads a schema back out for the pairing pass. Converting a real
+// Markdoc `Config['tags']` map into this format happens elsewhere, in
+// `scripts/generate-markdoc-schema.mjs`, which produces the committed
+// `src/data/markdoc-realm-schema.ts` re-exported below.
+import { MARKDOC_REALM_SCHEMA } from '../../data/markdoc-realm-schema.js';
+/**
+ * Merges a user's tags over a base schema's tags, in precedence order
+ * base -> file -> inline: inline `extend.tags` wins a collision with a
+ * `tagsFile` entry, which in turn wins over a built-in tag, since the more
+ * specific/local a source is, the more likely a project meant it to override.
+ * A name collision replaces the whole tag rather than deep-merging attribute
+ * by attribute, which matches how Markdoc's own `mergeConfig` composes its
+ * built-in tags with a project's: a tag definition is an atomic unit there,
+ * and `extend` follows the same rule rather than inventing a different merge
+ * granularity.
+ */
+function mergeExtend(base, extend) {
+    if (!extend)
+        return base;
+    const { fileTags, tags } = extend;
+    const hasFileTags = fileTags && Object.keys(fileTags).length > 0;
+    const hasTags = tags && Object.keys(tags).length > 0;
+    if (!hasFileTags && !hasTags)
+        return base;
+    return { tags: { ...base.tags, ...fileTags, ...tags } };
+}
+/**
+ * Normalizes the raw `markdoc` config value (boolean shorthand or object form)
+ * into `{ enabled, schema }`. It is called from `config/validate.ts` after AJV
+ * structural validation, but the check order there means it still sees the raw
+ * value when validation failed, so it must never throw on a malformed shape
+ * (`{ schema: 'bogus' }`, a bare string): anything unrecognized normalizes to
+ * disabled.
+ *
+ * `schema: false` deliberately is not "fully off". Parsing and pairing still
+ * run, and only the schema-dependent rules (unknown tag, and the
+ * unknown/required/enum attribute checks) go inert for lack of anything to check
+ * against. `extend` alongside `schema: false` is accepted structurally but has
+ * no effect, since there is no base to merge over.
+ *
+ * `resolvedExtend`, when passed, is the caller's already-loaded view of
+ * `extend` (`tagsFile` read and shape-checked, see config/validate.ts) and
+ * takes over from `raw.extend` entirely -- this module never reads a
+ * `tagsFile` itself, so a caller that resolved one has strictly more
+ * information than `raw.extend` alone.
+ */
+export function resolveMarkdocConfig(raw, resolvedExtend) {
+    if (raw === true) {
+        return { enabled: true, schema: MARKDOC_REALM_SCHEMA };
+    }
+    if (raw !== null && typeof raw === 'object') {
+        if (raw.schema === false) {
+            return { enabled: true, schema: null };
+        }
+        if (raw.schema === 'realm') {
+            return {
+                enabled: true,
+                schema: mergeExtend(MARKDOC_REALM_SCHEMA, resolvedExtend ?? raw.extend),
+            };
+        }
+        // Malformed object (e.g. `schema: 'bogus'`). AJV already reports this as a
+        // structural error, so defensively disable rather than throw.
+        return { enabled: false, schema: null };
+    }
+    // `undefined`, `false`, or any invalid non-boolean/non-object value.
+    return { enabled: false, schema: null };
+}
+/**
+ * Tag names a schema declares self-closing, in the plain `Set<string>` shape
+ * `pairing.ts` consumes so the pairing pass depends on none of this module's
+ * types.
+ */
+export function selfClosingTagNames(schema) {
+    const names = new Set();
+    for (const [name, tag] of Object.entries(schema.tags)) {
+        if (tag.selfClosing)
+            names.add(name);
+    }
+    return names;
+}
+//# sourceMappingURL=schema.js.map

package/dist/parser/markdoc/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/parser/markdoc/schema.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,gFAAgF;AAChF,6EAA6E;AAC7E,gFAAgF;AAChF,4EAA4E;AAC5E,6EAA6E;AAC7E,sEAAsE;AACtE,sEAAsE;AACtE,wDAAwD;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAgE1E;;;;;;;;;;GAUG;AACH,SAAS,WAAW,CAAC,IAAmB,EAAE,MAAkC;IAC1E,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC;IAClC,MAAM,WAAW,GAAG,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IACjE,MAAM,OAAO,GAAG,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IACrD,IAAI,CAAC,WAAW,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1C,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CAClC,GAA4C,EAC5C,cAA+B;IAK/B,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QACjB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC;IACzD,CAAC;IACD,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5C,IAAI,GAAG,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QACzC,CAAC;QACD,IAAI,GAAG,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YAC3B,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE,WAAW,CAAC,oBAAoB,EAAE,cAAc,IAAI,GAAG,CAAC,MAAM,CAAC;aACxE,CAAC;QACJ,CAAC;QACD,2EAA2E;QAC3E,8DAA8D;QAC9D,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAC1C,CAAC;IACD,qEAAqE;IACrE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,IAAI,GAAG,CAAC,WAAW;YAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/parser/markdoc/span.d.ts

@@ -0,0 +1,64 @@
+export type MarkdocTagKind = 'tag-open' | 'tag-close' | 'tag-self-closing' | 'annotation' | 'variable' | 'function';
+export type MarkdocValueKind = 'string' | 'number' | 'boolean' | 'null' | 'array' | 'object' | 'variable' | 'function' | 'bareword';
+export interface MarkdocAttribute {
+    name: string;
+    valueKind: MarkdocValueKind;
+    /** Literal value for string/number/boolean/null; raw source text otherwise. */
+    value: string | number | boolean | null;
+    /** 0-based offsets into the SPAN text, for child-token synthesis. */
+    nameStart: number;
+    nameEnd: number;
+    valueStart: number;
+    valueEnd: number;
+}
+/**
+ * A class (`.foo`) or id (`#bar`) shortcut inside a named tag's attribute list.
+ * Markdoc folds these into `class`/`id` attributes on the AST node; this parser
+ * keeps them in their own list instead, because a shortcut has no `name=value`
+ * source text and a pseudo attribute entry would carry lying offsets. Folding
+ * them into `class`/`id` is a schema-aware concern, not this parser's.
+ */
+export interface MarkdocShortcut {
+    kind: 'class' | 'id';
+    name: string;
+    start: number;
+    end: number;
+}
+export interface ParsedMarkdocSpan {
+    kind: MarkdocTagKind | 'malformed';
+    name: string | null;
+    attributes: MarkdocAttribute[];
+    nameStart: number;
+    nameEnd: number;
+    /** Markdoc's positional value slot right after the tag name ({% if $flag %}).
+     * Real Markdoc assigns it to the schema attribute literally named `primary`. */
+    primary?: {
+        valueKind: MarkdocValueKind;
+        value: string | number | boolean | null;
+        valueStart: number;
+        valueEnd: number;
+    };
+    /**
+     * Class/id shortcuts from a NAMED tag's attribute list, in source order.
+     * Absent (not an empty array) when none were found.
+     */
+    shortcuts?: MarkdocShortcut[];
+    reason?: string;
+    /**
+     * `malformed` only, and only when the scanner knew where it gave up: the
+     * 0-based span offset of the offending character. Kept as a number rather
+     * than baked into `reason` so a consumer can translate it into an absolute
+     * document position. Absent for causes with no single meaningful position,
+     * such as an empty body or a missing delimiter.
+     */
+    reasonOffset?: number;
+}
+/**
+ * Parses one Markdoc `{% ... %}` span's text into its kind, name,
+ * attributes, and offsets. `spanText` is expected to be exactly the span
+ * (e.g. as recognized by the tokenizer) -- offsets in the result are
+ * 0-based indexes into this same string. Never throws; unparseable input
+ * comes back as `{ kind: 'malformed', reason }`.
+ */
+export declare function parseMarkdocSpan(spanText: string): ParsedMarkdocSpan;
+//# sourceMappingURL=span.d.ts.map

package/dist/parser/markdoc/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/span.ts"],"names":[],"mappings":"AAsEA,MAAM,MAAM,cAAc,GACtB,UAAU,GACV,WAAW,GACX,kBAAkB,GAClB,YAAY,GACZ,UAAU,GACV,UAAU,CAAC;AACf,MAAM,MAAM,gBAAgB,GACxB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,MAAM,GACN,OAAO,GACP,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IACxC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,cAAc,GAAG,WAAW,CAAC;IACnC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB;oFACgF;IAChF,OAAO,CAAC,EAAE;QACR,SAAS,EAAE,gBAAgB,CAAC;QAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;QACxC,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAgeD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAyNpE"}