@molecule/api-ai-tools 1.13.0 → 1.14.0

package/dist/command-position.js

@@ -32,10 +32,246 @@
  *
  * @module
  */
-/** A command's words, quotes kept whole — the same reading a printed-source check uses. */
-const WORD = /"(?:\\.|[^"\\])*"|'[^']*'|\S+/g;
 /** Shell words that stand alone: grouping, never an argument. */
 const GROUPING = new Set(['(', ')', '{', '}']);
+/** The index just past a single-quoted string that starts at `at` (its opening quote). */
+function singleQuotedEnd(text, at) {
+    const close = text.indexOf("'", at + 1);
+    return close === -1 ? text.length : close + 1;
+}
+/**
+ * The index just past a double-quoted string that starts at `at`. A command substitution or a
+ * backtick inside it is skipped as a unit, because a `"` inside one belongs to the nested command,
+ * not to this string (`DIR="$(cd "$(dirname "$0")" && pwd)"`).
+ */
+function doubleQuotedEnd(text, at) {
+    let i = at + 1;
+    while (i < text.length) {
+        const char = text[i] ?? '';
+        if (char === '\\') {
+            i += 2;
+            continue;
+        }
+        if (char === '"')
+            return i + 1;
+        if (char === '`') {
+            i = backtickEnd(text, i);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '(') {
+            i = substitutionEnd(text, i + 2);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '{') {
+            i = parameterEnd(text, i + 2);
+            continue;
+        }
+        i += 1;
+    }
+    return text.length;
+}
+/** The index just past a backtick substitution that starts at `at` (`\`` is literal, not a close). */
+function backtickEnd(text, at) {
+    let i = at + 1;
+    while (i < text.length) {
+        if (text[i] === '\\') {
+            i += 2;
+            continue;
+        }
+        if (text[i] === '`')
+            return i + 1;
+        i += 1;
+    }
+    return text.length;
+}
+/**
+ * The index just past a `$( … )` command substitution whose body starts at `at`. The body is NOT
+ * evaluated and its whitespace splits nothing: only its closing `)` is looked for, through quotes,
+ * escapes and nested substitutions. An unclosed substitution runs to the end of the text.
+ */
+function substitutionEnd(text, at) {
+    let depth = 1;
+    let i = at;
+    while (i < text.length) {
+        const char = text[i] ?? '';
+        // A `#` in the nested command starts a comment, so a `$(` or `)` inside it is data — the same
+        // reading `splitCommand` makes (`$(printf x # $(` opens nothing).
+        if (char === '#' && commentStartsAt(text, i)) {
+            const newline = text.indexOf('\n', i);
+            i = newline === -1 ? text.length : newline;
+            continue;
+        }
+        if (char === '\\') {
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            i = singleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '"') {
+            i = doubleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '`') {
+            i = backtickEnd(text, i);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '(') {
+            i = substitutionEnd(text, i + 2);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '{') {
+            i = parameterEnd(text, i + 2);
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        else if (char === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+        i += 1;
+    }
+    return text.length;
+}
+/** The index just past a `${ … }` parameter expansion whose body starts at `at`. */
+function parameterEnd(text, at) {
+    let depth = 1;
+    let i = at;
+    while (i < text.length) {
+        const char = text[i] ?? '';
+        if (char === '\\') {
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            i = singleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '"') {
+            i = doubleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '`') {
+            i = backtickEnd(text, i);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '(') {
+            i = substitutionEnd(text, i + 2);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '{') {
+            depth += 1;
+            i += 2;
+            continue;
+        }
+        if (char === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+        i += 1;
+    }
+    return text.length;
+}
+/**
+ * The index just past the shell word that starts at `at` (a non-whitespace character): a word ends
+ * at unquoted whitespace, and every quoted part, command substitution (`$( … )`, backticks),
+ * parameter expansion (`${ … }`) and process substitution (`<( … )`) inside it is skipped as a
+ * unit — so the spaces in `UID_VAL=h$(date +%s)` belong to that one word.
+ *
+ * Nothing is evaluated or expanded: this finds word BOUNDARIES only, and returns the text as
+ * written. A backslash-newline is a line continuation, so it ends the word and is skipped.
+ */
+function shellWordEnd(text, at) {
+    let i = at;
+    while (i < text.length) {
+        const char = text[i] ?? '';
+        if (/\s/.test(char))
+            break;
+        // Grouping punctuation is a shell operator, never part of the word beside it (`tail -25)`,
+        // `(npx …`), so a caller can step over the closer the way it always has.
+        if (GROUPING.has(char))
+            break;
+        if (char === '\\') {
+            if (text[i + 1] === '\n')
+                break;
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            i = singleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '"') {
+            i = doubleQuotedEnd(text, i);
+            continue;
+        }
+        if (char === '`') {
+            i = backtickEnd(text, i);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '(') {
+            i = substitutionEnd(text, i + 2);
+            continue;
+        }
+        if (char === '$' && text[i + 1] === '{') {
+            i = parameterEnd(text, i + 2);
+            continue;
+        }
+        if ((char === '<' || char === '>') && text[i + 1] === '(') {
+            i = substitutionEnd(text, i + 2);
+            continue;
+        }
+        i += 1;
+    }
+    return i;
+}
+/** One text's shell words, quotes kept, grouping punctuation still its own word. */
+function shellWordSpans(text) {
+    const words = [];
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i] ?? '';
+        if (char === '\\' && text[i + 1] === '\n') {
+            i += 2;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            i += 1;
+            continue;
+        }
+        if (GROUPING.has(char)) {
+            words.push({ text: char, start: i });
+            i += 1;
+            continue;
+        }
+        const end = shellWordEnd(text, i);
+        words.push({ text: text.slice(i, end), start: i });
+        i = end;
+    }
+    return words;
+}
+/**
+ * The words {@link segmentWords} keeps, with the offset each was written at: quotes kept whole,
+ * grouping words dropped, and a leading `(`/`{` taken off the first word. One walk answers both
+ * readings, so a caller splicing text at a word's offset and a caller matching that word can
+ * never disagree.
+ */
+function segmentWordSpans(text) {
+    const words = shellWordSpans(text).filter((word) => !GROUPING.has(word.text));
+    const first = words[0];
+    if (first !== undefined) {
+        const bare = first.text.replace(/^[({]+/, '');
+        if (bare === '')
+            words.shift();
+        else if (bare !== first.text)
+            words[0] = { text: bare, start: first.start + (first.text.length - bare.length) };
+    }
+    return words;
+}
 /**
  * A redirection written as ONE word, its target attached: `2>&1`, `>out.log`, `&>/dev/null`,
  * `<<'EOF'`. Matched against a word of the statement, so a redirect's target written as its own
@@ -707,6 +943,8 @@ function splitCommand(command) {
     const source = blankHeredocBodies(command);
     const parts = [];
     const substitutions = [];
+    const subshells = [];
+    const subshellOpens = [];
     /** Where each open `$(` body starts; -1 for a bare `(` opened inside one. */
     const subOpens = [];
     /** Where each open backtick body starts. */
@@ -855,11 +1093,18 @@ function splitCommand(command) {
         // `{ … }` writes through that group, so the depth travels with every character a caller
         // reading a redirect may ask about.
         if (char === '(' || char === '{') {
+            if (char === '(')
+                subshellOpens.push(i + 1);
             put(char);
             groupDepth += 1;
             continue;
         }
         if (char === ')' || char === '}') {
+            if (char === ')') {
+                const start = subshellOpens.pop();
+                if (start !== undefined)
+                    subshells.push({ start, end: i });
+            }
             groupDepth = Math.max(0, groupDepth - 1);
             put(char);
             continue;
@@ -903,7 +1148,9 @@ function splitCommand(command) {
         });
         lastAfter = part.after;
     }
-    return { parts: out, substitutions };
+    for (const start of subshellOpens)
+        subshells.push({ start, end: source.length });
+    return { parts: out, substitutions, subshells };
 }
 /**
  * A command's statements and pipeline stages — {@link splitCommand}'s parts on their own.
@@ -980,20 +1227,8 @@ function redirectTargetOf(text, depths, program, args) {
  * @returns The words.
  */
 function segmentWords(text) {
-    const words = text.match(WORD) ?? [];
-    const cleaned = words.filter((word) => !GROUPING.has(word));
-    const first = cleaned[0];
-    if (first !== undefined) {
-        const bare = first.replace(/^[({]+/, '');
-        if (bare === '')
-            cleaned.shift();
-        else
-            cleaned[0] = bare;
-    }
-    return cleaned;
+    return segmentWordSpans(text).map((word) => word.text);
 }
-/** {@link WORD} anchored at an offset, for walking a statement's raw words. */
-const WORD_AT = new RegExp(WORD.source, 'y');
 /**
  * A statement's own leading `NAME=value` words, and where they end.
  *
@@ -1008,19 +1243,25 @@ function leadingAssignments(text) {
     const words = [];
     let at = 0;
     for (let guard = 0; guard < MAX_WRAPPERS; guard++) {
-        while (at < text.length && /\s/.test(text[at] ?? ''))
+        while (at < text.length) {
+            if (text[at] === '\\' && text[at + 1] === '\n') {
+                at += 2;
+                continue;
+            }
+            if (!/\s/.test(text[at] ?? ''))
+                break;
             at += 1;
+        }
         // Grouping in front of the statement (`(npx …)`, `{ …`): not a word the shell assigns with.
         if (text[at] === '(' || text[at] === '{') {
             at += 1;
             continue;
         }
-        WORD_AT.lastIndex = at;
-        const match = WORD_AT.exec(text);
-        if (!match || !ENV_ASSIGNMENT.test(match[0]))
+        const word = text.slice(at, shellWordEnd(text, at));
+        if (!ENV_ASSIGNMENT.test(word))
             return { words, end: at };
-        words.push(match[0]);
-        at += match[0].length;
+        words.push(word);
+        at += word.length;
     }
     return { words, end: at };
 }
@@ -1117,6 +1358,31 @@ function executedCommandsOf(command, depth) {
     }
     return out;
 }
+/**
+ * The direct executable command-substitution bodies in shell text, in source order.
+ *
+ * Uses the same quote, comment and heredoc boundaries as {@link executedCommands}.
+ * Single-quoted and escaped text is inert. Nested substitutions stay inside their
+ * parent's body so a caller can recurse with a separate working-directory scope
+ * for each body; a `cd` inside one must not affect its sibling or the outer shell.
+ *
+ * @param command - The shell text to read, including any leading assignments.
+ * @returns Each direct `$(…)` or backtick body, without its delimiters.
+ */
+export function commandSubstitutions(command) {
+    if (typeof command !== 'string' || !command.trim())
+        return [];
+    const { substitutions } = splitCommand(command);
+    const bodies = [];
+    let parentEnd = -1;
+    for (const { start, end } of substitutions.sort((a, b) => a.start - b.start || b.end - a.end)) {
+        if (start < parentEnd)
+            continue;
+        bodies.push(command.slice(start, end));
+        parentEnd = end;
+    }
+    return bodies;
+}
 /**
  * Every command a shell command actually executes, at any depth — the statements themselves, the
  * body of a `sh -c '<command>'`, and the body of every command substitution (`$(…)`, backticks).
@@ -1154,29 +1420,7 @@ export function executedCommands(command) {
  * @returns The word's offset in `text`, or null when there is no such word.
  */
 function wordOffset(text, index) {
-    const placement = new RegExp(WORD.source, 'g');
-    let kept = 0;
-    let first = true;
-    for (let match = placement.exec(text); match !== null; match = placement.exec(text)) {
-        if (GROUPING.has(match[0]))
-            continue;
-        if (first) {
-            first = false;
-            const bare = match[0].replace(/^[({]+/, '');
-            // `segmentWords` shifts a first word that was nothing but grouping away, so the NEXT word
-            // is not stripped and is counted from zero.
-            if (bare === '')
-                continue;
-            if (kept === index)
-                return match.index + (match[0].length - bare.length);
-            kept += 1;
-            continue;
-        }
-        if (kept === index)
-            return match.index;
-        kept += 1;
-    }
-    return null;
+    return segmentWordSpans(text)[index]?.start ?? null;
 }
 /**
  * Every statement of a command, with its own assignments and where it sits — assignment-only
@@ -1289,9 +1533,9 @@ export function statementArgumentEnd(command, start, end) {
         }
         at = cursor - 1;
     }
-    const words = [...command.slice(start, at).matchAll(new RegExp(WORD.source, 'g'))].map((m) => ({
-        text: m[0],
-        index: start + (m.index ?? 0),
+    const words = shellWordSpans(command.slice(start, at)).map((word) => ({
+        text: word.text,
+        index: start + word.start,
     }));
     // A trailing redirection belongs to the statement but is not an argument of its program. An
     // option written after it would still parse, but the option belongs with the program's own
@@ -1404,7 +1648,8 @@ function locatedSegmentsOf(command, depth) {
     if (typeof command !== 'string' || depth > MAX_NESTING)
         return [];
     const out = [];
-    for (const part of splitSegments(command)) {
+    const { parts, subshells } = splitCommand(command);
+    for (const part of parts) {
         const words = segmentWords(part.text);
         const start = commandStart(words);
         const leading = leadingAssignments(part.text);
@@ -1428,6 +1673,12 @@ function locatedSegmentsOf(command, depth) {
                 : part.start + (wordOffset(part.text, start.envInsert) ?? leading.end),
             programOffset: words[start.at] === undefined ? null : part.start + (wordOffset(part.text, start.at) ?? 0),
         };
+        const scopeAt = placed.programOffset ?? part.start + (wordOffset(part.text, 0) ?? 0);
+        const shellScope = subshells
+            .filter(({ start, end }) => start <= scopeAt && scopeAt < end)
+            .sort((a, b) => a.start - b.start)
+            .map(({ start }) => `group:${start}`);
+        const scoped = shellScope.length === 0 ? {} : { shellScope };
         // The runner the word RUNS names, when that is not the word's own name (`node <path>/playwright`
         // is a `playwright` invocation, xr-molecule-flash-m179).
         const program = words[start.at] === undefined ? '' : (start.program ?? programName(words[start.at] ?? ''));
@@ -1441,9 +1692,14 @@ function locatedSegmentsOf(command, depth) {
                     continue;
                 out.push({
                     ...entry,
+                    shellScope: [...shellScope, `shell:${part.start}`, ...(entry.shellScope ?? [])],
                     // The variables this statement bound before the shell reached it are the nested
                     // command's too: `env BASE_URL=… sh -c '… npx playwright test …'` passes them down.
                     assignments: [...new Set([...assignments, ...entry.assignments])],
+                    sourceAssignments: [
+                        ...(i === 0 ? assignments : []),
+                        ...(entry.sourceAssignments ?? entry.assignments),
+                    ],
                     // A nested statement's positions are positions in the nested string, not in this
                     // command. The FIRST one keeps this statement's own separator: the shell reads the
                     // nested string where this statement stands.
@@ -1469,6 +1725,7 @@ function locatedSegmentsOf(command, depth) {
             if (assignments.length > 0)
                 out.push({
                     segment: null,
+                    ...scoped,
                     assignments,
                     ...placed,
                     programOffset: null,
@@ -1479,6 +1736,7 @@ function locatedSegmentsOf(command, depth) {
             continue;
         }
         out.push({
+            ...scoped,
             segment: {
                 program,
                 args,
@@ -1554,16 +1812,13 @@ export function withoutTimeoutWrapper(command, which) {
             continue;
         // Every word in front of the program: the assignments and the wrappers. The duration belongs
         // to the wrapper, so the walk has to see the words, not just the parse's total bound.
-        const prefix = command.slice(located.start, located.programOffset);
-        const words = [];
-        const at = new RegExp(WORD.source, 'g');
-        for (let match = at.exec(prefix); match !== null; match = at.exec(prefix)) {
-            words.push({
-                text: match[0],
-                start: located.start + match.index,
-                end: located.start + match.index + match[0].length,
-            });
-        }
+        const start = located.start;
+        const prefix = command.slice(start, located.programOffset);
+        const words = shellWordSpans(prefix).map((word) => ({
+            text: word.text,
+            start: start + word.start,
+            end: start + word.start + word.text.length,
+        }));
         for (let i = 0; i < words.length; i += 1) {
             const word = words[i];
             if (word === undefined || programName(word.text) !== 'timeout')

package/dist/suite-overlap.d.ts

@@ -79,13 +79,17 @@ export declare function namesSuiteConfig(command: string): boolean;
 export declare function withSuiteConfig(command: string, config: string | null | undefined): string;
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
- * invocation — same directory, same settings — with the named `file:line`s in place of the whole
- * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
+ * invocation — same launcher, same settings — with the named `file:line`s in place of every
+ * positional selection the run carried (a spec file, a suite directory or a regex filter),
+ * `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
  * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
- * the target is rewritten to a fresh sibling ({@link redirectToFreshFile}), so a re-run never
- * overwrites the log the run itself is the evidence for (xr-molecule-flash-m173).
+ * the target is rewritten to a fresh sibling ({@link redirectRunnerOutputsToFreshFiles}), so a
+ * re-run never overwrites the log the run itself is the evidence for (xr-molecule-flash-m173) —
+ * and the setup around the run keeps its own file writes untouched (xr-molecule-flash-m429). A
+ * `tail`/`head`/`cat`/`grep` chained after the run that reads that exact log is shown the fresh
+ * sibling instead, so the re-run displays the run it performed (xr-molecule-flash-o03).
  *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,GACjC,MAAM,CA8CR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAkHD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AA2FD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAYtF"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAaH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AA4VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,GACjC,MAAM,CAgDR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAwOD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AA2FD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAYtF"}