apify-test-tools 0.10.2-beta.1 → 0.10.2-beta.11

package/bin/main.ts

@@ -6,25 +6,15 @@ import yargs, { type Options } from 'yargs';
 // eslint-disable-next-line import/extensions --- With .js, it cannot find types
 import { hideBin } from 'yargs/helpers';
 
-import { deleteOldBuilds, runBuilds } from './build.js';
+import { getAffectedActors } from './affected-actors.js';
+import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
-import { getChangedActors } from './diff-changes.js';
-import {
-    getBranchOnlyChangedFiles,
-    getChangedFiles,
-    getCommits,
-    getCurrentBranch,
-    getReleaseChanges,
-    getRepoName,
-    hasMergeFromTarget,
-    resolveReleaseBaseCommit,
-    resolveRepoUrl,
-} from './git.js';
+import { getChangedFiles, getCommits } from './git.js';
 import { logger, logLevels } from './logger.js';
 import { writeJson } from './output.js';
 import { notifyToSlack } from './slack.js';
+import { parseBuildInput, parseReleaseChanges, readStdin } from './stdin-input.js';
 import { reportTestResults } from './test-report.js';
-import type { Config } from './types.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
 /**
@@ -64,9 +54,66 @@ const actorSelectionOptions = {
     ignore: { type: 'string', array: true, default: [] as string[] },
 } as const satisfies Record<string, Options>;
 
-/** Flags for commands that trigger Apify builds. */
+/**
+ * Commit range for get-affected-actors, which always ends at the checked-out HEAD. `base` and `since` combine:
+ * `base` alone is a branch's own commits (a PR), `since` alone is everything after a commit (a release), both is
+ * a branch after its last validated commit.
+ */
+const affectedRangeOptions = {
+    base: { type: 'string', describe: 'Only count commits on HEAD that are not on this branch' },
+    since: {
+        type: 'string',
+        describe: 'Only count commits after this one. Ignored with --base if it is not on the branch',
+    },
+    'test-files-glob': {
+        type: 'string',
+        describe: 'Glob (from the repo root) of test files that count as changes even when .dockerignore lists them',
+    },
+} as const satisfies Record<string, Options>;
+
+/**
+ * For commands that change something (builds, deletes, Slack posts). A dry run still does every read and check
+ * the real run does, credentials included, and only skips the writes. So it needs the same tokens, though
+ * read-only ones are enough. Read-only commands don't take it since they have nothing to skip.
+ */
+const dryRunOptions = {
+    'dry-run': {
+        type: 'boolean',
+        default: false,
+        describe: 'Do every read and check (tokens included) but change nothing; print what would be done',
+    },
+} as const satisfies Record<string, Options>;
+
+/** Flags of `build`, which builds exactly the Actors it is given. */
 const buildOptions = {
-    'use-docker-cache': { type: 'boolean', default: false },
+    'version-number': {
+        type: 'string',
+        demandOption: true,
+        describe: `Version to build, like 0.1, or "${DEFAULT_VERSION_KEYWORD}" for each Actor's default version`,
+        coerce: (value: string) => {
+            if (value !== DEFAULT_VERSION_KEYWORD && !/^\d+\.\d+$/.test(value)) {
+                throw new Error(
+                    `--version-number must look like 0.1 or be "${DEFAULT_VERSION_KEYWORD}", got "${value}"`,
+                );
+            }
+            return value;
+        },
+    },
+} as const satisfies Record<string, Options>;
+
+/** For the commands that build a version other than the default one, see assertEnvVarsMatchDefaultVersion. */
+const envVarsSyncOptions = {
+    'require-env-vars-in-sync': {
+        type: 'boolean',
+        default: false,
+        describe: "Fail unless the built version's env var names match the default version's",
+    },
+} as const satisfies Record<string, Options>;
+
+/** Where `notify-release` posts the release. */
+const releaseSlackOptions = {
+    'report-slack-channel': { type: 'string', describe: 'Channel for the full report: commits and changed files' },
+    'release-slack-channel': { type: 'string', describe: 'Channel for the changelog additions only' },
 } as const satisfies Record<string, Options>;
 
 /** Global flags, available to every command. */
@@ -77,51 +124,8 @@ const globalOptions = {
         default: 'info',
         describe: 'Minimum diagnostic level written to stderr; silent disables logging',
     },
-    'dry-run': { type: 'boolean', default: false },
 } as const satisfies Record<string, Options>;
 
-const resolveChangedActors = async (config: Config, { isLatest }: { isLatest: boolean }) => {
-    const actorConfigs = await readConfigFile(config);
-
-    // This is an optimization for the common case where a branch only has cosmetic changes but had to smerge in
-    // functional changes from master (being up-to-date is a CI requirement). Master is already validated, and
-    // since the branch has no functional changes of its own, there is nothing new to validate.
-    // Exception: if the branch has any functional changes alongside the merge, we must re-test — even
-    // individually validated changes can have novel interactions when combined.
-    if (await hasMergeFromTarget(config.sourceBranch, config.targetBranch)) {
-        logger.info(
-            '[MERGE-FROM-TARGET-OPTIMIZATION]: There is merge from target branch, checking if there are no functional changes in our own branch. If so, we can skip tests',
-        );
-        const branchOnlyFiles = await getBranchOnlyChangedFiles(config.sourceBranch, config.targetBranch);
-        // Omit baseCommit to get full branch history. Validated functional commits can still interact with merged ones
-        const allBranchCommits = await getCommits({ ...config, baseCommit: undefined });
-        const branchOnlyActorsChanged = await getChangedActors({
-            filepathsChanged: branchOnlyFiles,
-            actorConfigs,
-            commits: allBranchCommits,
-            testFilesGlob: config.testFilesGlob,
-        });
-        if (branchOnlyActorsChanged.length === 0) {
-            logger.info('[MERGE-FROM-TARGET-OPTIMIZATION]: Branch itself has no functional changes, skipping tests');
-            return [];
-        }
-        logger.info(
-            `[MERGE-FROM-TARGET-OPTIMIZATION]: Branch has ${branchOnlyActorsChanged.length} functional changes, cannot optimize, we continue with full check`,
-        );
-    }
-
-    // If the optimization doesn't apply, we check all branch commits including merges for full coverage. We don't reuse the merge optimization results because here we can apply baseCommit and check merge commits (they might be functional or just cosmetic)
-    const commits = await getCommits(config);
-    const changedFiles = await getChangedFiles(commits);
-    return getChangedActors({
-        filepathsChanged: changedFiles,
-        actorConfigs,
-        isLatest,
-        commits,
-        testFilesGlob: config.testFilesGlob,
-    });
-};
-
 await yargs()
     .scriptName('public-actors-utils')
     .options(globalOptions)
@@ -167,11 +171,10 @@ await yargs()
     )
     .command(
         'get-affected-actors',
-        '',
-        (y) => y.options(gitRangeOptions).options(actorSelectionOptions),
-        async (config) => {
-            const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            writeJson(actorsChanged);
+        'Find the Actors whose context changed in a commit range ending at the checked-out HEAD',
+        (y) => y.options(affectedRangeOptions).options(actorSelectionOptions),
+        async (args) => {
+            writeJson(await getAffectedActors(args));
         },
     )
     .command(
@@ -179,6 +182,7 @@ await yargs()
         '',
         (y) =>
             y
+                .options(dryRunOptions)
                 .option('report-file', { type: 'string', demandOption: true })
                 .option('report-slack-channel', { type: 'string' })
                 .option('job-url', { type: 'string' })
@@ -189,100 +193,57 @@ await yargs()
     )
     .command(
         'build',
-        '',
-        (y) =>
-            y
-                .options(gitRangeOptions)
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                .option('test-files-glob', { type: 'string' }),
-        async (config) => {
-            const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            const builds = await runBuilds({
-                ...(await resolveRepoUrl(config.repoUrl)),
-                actorConfigs: actorsChanged,
-                branch: config.sourceBranch.replace('origin/', ''),
-                dryRun: config.dryRun,
-                useDockerCache: config.useDockerCache,
+        'Build the Actors listed on stdin, as {"actors": [{"actorFullName": ...}]}, from the checked-out branch',
+        (y) => y.options(buildOptions).options(repoUrlOptions).options(envVarsSyncOptions).options(dryRunOptions),
+        async (args) => {
+            const input = parseBuildInput(await readStdin());
+            const names = input.actors.map(({ actorFullName }) => actorFullName);
+            // An empty --actors selects every Actor, but an empty list here means there is nothing to build
+            const actorConfigs = names.length > 0 ? await readConfigFile({ actors: names, ignore: [] }) : [];
+            const builds = await buildActors({
+                actorConfigs,
+                versionNumber: args.versionNumber,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
+                requireEnvVarsInSync: args.requireEnvVarsInSync,
             });
             writeJson(builds);
         },
     )
     .command(
-        'release',
-        '',
-        (y) =>
-            y
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                // The last commit that is already released, everything after it up to HEAD gets released.
-                // Required, see the README section "Releasing Actors" for how to set it for each merge strategy.
-                .option('base-commit', { type: 'string', demandOption: true })
-                .option('report-slack-channel', { type: 'string' })
-                .option('release-slack-channel', { type: 'string' }),
+        'notify-release',
+        'Announce a release on Slack, from the get-affected-actors output on stdin',
+        (y) => y.options(releaseSlackOptions).options(repoUrlOptions).options(dryRunOptions),
         async (args) => {
-            const baseSha = await resolveReleaseBaseCommit(args.baseCommit);
-            const branch = await getCurrentBranch();
-            const changes = await getReleaseChanges(baseSha);
-            if (!changes) {
-                logger.info(`HEAD is the base commit ${baseSha}, there is nothing new to release`);
-                return;
-            }
-            const { commits, changedFiles, changelog } = changes;
-            const { repoUrl, shouldVerifyRepoUrl } = await resolveRepoUrl(args.repoUrl);
-
-            const isLatest = true;
-            const actorConfigs = await readConfigFile(args);
-            const actorsChanged = await getChangedActors({
-                filepathsChanged: changedFiles,
-                actorConfigs,
-                isLatest,
-                commits,
-            });
-            const { dryRun, reportSlackChannel, releaseSlackChannel } = args;
-            const builds = await runBuilds({
-                isLatest,
-                repoUrl,
-                shouldVerifyRepoUrl,
-                actorConfigs: actorsChanged,
-                branch,
-                dryRun,
-                useDockerCache: args.useDockerCache,
-            });
-            logger.info(JSON.stringify(builds));
-
+            const { commits, changedFiles, changelog } = parseReleaseChanges(await readStdin());
             await notifyToSlack({
-                changedFiles,
                 commits,
+                changedFiles,
                 changelog,
-                repository: getRepoName(repoUrl),
-                dryRun,
-                // The newest commit, same as the pushed head commit
-                author: commits[commits.length - 1].author,
-                reportSlackChannel,
-                releaseSlackChannel,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
+                reportSlackChannel: args.reportSlackChannel,
+                releaseSlackChannel: args.releaseSlackChannel,
             });
         },
     )
     .command(
         'build-from-local',
         '',
-        (y) => y.options(actorSelectionOptions),
-        async ({ actors, ignore, dryRun }) => {
+        (y) => y.options(actorSelectionOptions).options(envVarsSyncOptions).options(dryRunOptions),
+        async ({ actors, ignore, dryRun, requireEnvVarsInSync }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
-            const builds = await runBuildsFromLocal({ actorConfigs, dryRun });
+            const builds = await runBuildsFromLocal({ actorConfigs, dryRun, requireEnvVarsInSync });
             writeJson(builds);
         },
     )
     .command(
         'delete-old-builds',
         '',
-        (y) => y.options(actorSelectionOptions),
-        async ({ actors, ignore }) => {
+        (y) => y.options(actorSelectionOptions).options(dryRunOptions),
+        async ({ actors, ignore, dryRun }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
-            await deleteOldBuilds(actorConfigs);
+            await deleteOldBuilds(actorConfigs, { dryRun });
         },
     )
     .strictCommands()

package/bin/slack.ts

@@ -1,46 +1,80 @@
 import { WebClient } from '@slack/web-api';
 
+import { getRepoName, resolveRepoUrl } from './git.js';
 import { logger } from './logger.js';
 import type { Commit } from './types.js';
 import { getEnvVar } from './utils.js';
 
 type NotifyToSlackOptions = {
-    repository: string;
     changedFiles: string[];
     changelog: string | null;
     commits: Commit[];
+    // Defaults to the `origin` remote, see resolveRepoUrl
+    repoUrl?: string;
     dryRun: boolean;
-    author: string;
     releaseSlackChannel?: string;
     reportSlackChannel?: string;
 };
 
+/**
+ * Creates the client the real run posts with. A dry run posts nothing but still requires the token and checks
+ * Slack accepts it (`auth.test` is read-only), so it fails wherever the real run would.
+ */
+export const getSlackClient = async (tokenEnvVar: string, dryRun: boolean): Promise<WebClient> => {
+    const slack = new WebClient(getEnvVar(tokenEnvVar));
+    if (dryRun) {
+        try {
+            await slack.auth.test();
+        } catch (err) {
+            throw new Error(`${tokenEnvVar} was rejected by Slack: ${(err as Error).message}`);
+        }
+        logger.info(`[DRY RUN] ${tokenEnvVar} is valid`);
+    }
+    return slack;
+};
+
+export const sendingLabel = (dryRun: boolean) => (dryRun ? '[DRY RUN] Would send' : 'Sending');
+
 // Git authors come as "Name<email>", Slack only needs the name
 const displayName = (author: string) => author.replace(/\s*<[^>]*>$/, '');
 
+/**
+ * Posts what a release changed: its commits, changed files and changelog, as get-affected-actors reports them.
+ * Posts nothing when there are no commits, which means there is nothing new to release.
+ */
 export const notifyToSlack = async ({
     changedFiles,
     commits,
     changelog,
-    repository,
+    repoUrl,
     dryRun,
-    author,
     releaseSlackChannel,
     reportSlackChannel,
 }: NotifyToSlackOptions) => {
-    const slack = new WebClient(getEnvVar('SLACK_TOKEN_RELEASES_BOT'));
-
+    if (commits.length === 0) {
+        logger.info('No new commits, so there is no release to announce');
+        return;
+    }
     if (!changelog) {
         logger.warn('No new changelog entries found, did you forget to update it?');
     }
 
+    if (!releaseSlackChannel && !reportSlackChannel) {
+        logger.info('Skipping slack notification, no --release-slack-channel or --report-slack-channel passed');
+        return;
+    }
+    const slack = await getSlackClient('SLACK_TOKEN_RELEASES_BOT', dryRun);
+
+    const repository = getRepoName((await resolveRepoUrl(repoUrl)).repoUrl);
+    // The newest commit, same as the pushed head commit
+    const { author } = commits[commits.length - 1];
     let shortMessage = `*${repository}* – New release (by ${displayName(author)}):\n\n`;
 
     // This one is just for broader public that only cares about public facing changes
     if (changelog && releaseSlackChannel) {
         shortMessage += `*Additions to the changelog*:\n\n${changelog}\n`;
         logger.info(`=========================================`);
-        logger.info(`**Sending slack message to channel**: ${releaseSlackChannel}.\n\n${shortMessage}`);
+        logger.info(`**${sendingLabel(dryRun)} slack message to channel**: ${releaseSlackChannel}.\n\n${shortMessage}`);
         logger.info(`=========================================`);
         if (!dryRun) {
             await slack.chat.postMessage({
@@ -62,7 +96,7 @@ export const notifyToSlack = async ({
     // This one is for devs and project managers that need to know more details
     if (reportSlackChannel) {
         logger.info(`=========================================`);
-        logger.info(`Sending slack message to channel: ${reportSlackChannel}.\n\n${longMessage}`);
+        logger.info(`${sendingLabel(dryRun)} slack message to channel: ${reportSlackChannel}.\n\n${longMessage}`);
         logger.info(`=========================================`);
         if (!dryRun) {
             await slack.chat.postMessage({
@@ -73,8 +107,7 @@ export const notifyToSlack = async ({
     }
 };
 
-export const sendSlackMessage = async (channel: string, text: string, blocks: string[], token: string) => {
-    const slack = new WebClient(token);
+export const sendSlackMessage = async (slack: WebClient, channel: string, text: string, blocks: string[]) => {
     const { ts } = await slack.chat.postMessage({ text, channel });
     if (blocks.length > 0 && ts) {
         await slack.chat.postMessage({

package/bin/stdin-input.ts

@@ -0,0 +1,65 @@
+import process from 'node:process';
+
+import z, { prettifyError, type ZodType } from 'zod';
+
+export const readStdin = async (): Promise<string> => {
+    // Nothing piped in: fail right away instead of waiting for someone to type
+    if (process.stdin.isTTY) {
+        throw new Error('Expected JSON on stdin, but nothing was piped in.');
+    }
+    let raw = '';
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+    }
+    return raw;
+};
+
+const parseStdinJson = <T>(
+    raw: string,
+    schema: ZodType<T>,
+    { expected, example }: { expected: string; example: string },
+) => {
+    // Empty input is an error, not "nothing to do": it is what a failed command earlier in the pipe leaves behind
+    if (!raw.trim()) {
+        throw new Error(`Expected ${expected} as JSON on stdin, got nothing (${example}).`);
+    }
+    let json: unknown;
+    try {
+        json = JSON.parse(raw);
+    } catch (error) {
+        throw new Error(`The input on stdin is not valid JSON: ${(error as Error).message}`);
+    }
+    const result = schema.safeParse(json);
+    if (!result.success) {
+        throw new Error(`The input on stdin is not ${expected} (${example}):\n${prettifyError(result.error)}`);
+    }
+    return result.data;
+};
+
+/**
+ * What `build` reads: the Actors to build. Only their names are read, the config file stays the source of truth
+ * for everything else about them. Other fields are ignored, so a get-affected-actors document only needs its Actor
+ * list picked, e.g. `jq '{ actors: .functionallyChangedActors }'`.
+ */
+const buildInputSchema = z.object({
+    actors: z.array(z.object({ actorFullName: z.string() })),
+});
+
+export const parseBuildInput = (raw: string) =>
+    parseStdinJson(raw, buildInputSchema, {
+        expected: 'the Actors to build',
+        example: `e.g. echo '{"actors":[{"actorFullName":"owner/name"}]}' | apify-test-tools build --version-number 0.1`,
+    });
+
+/** What `notify-release` reads: the parts of a get-affected-actors document that describe what changed. */
+const releaseChangesSchema = z.object({
+    commits: z.array(z.object({ sha: z.string(), author: z.string(), date: z.string(), message: z.string() })),
+    changedFiles: z.array(z.string()),
+    changelog: z.string().nullable(),
+});
+
+export const parseReleaseChanges = (raw: string) =>
+    parseStdinJson(raw, releaseChangesSchema, {
+        expected: 'the output of get-affected-actors',
+        example: 'e.g. apify-test-tools get-affected-actors --since <sha> | apify-test-tools notify-release',
+    });

package/bin/test-report.ts

@@ -1,8 +1,7 @@
 import fs from 'node:fs/promises';
 
 import { logger } from './logger.js';
-import { sendSlackMessage } from './slack.js';
-import { getEnvVar } from './utils.js';
+import { getSlackClient, sendingLabel, sendSlackMessage } from './slack.js';
 
 interface ReportTestResultsOptions {
     reportFile: string;
@@ -80,6 +79,9 @@ export const reportTestResults = async ({
         );
         return;
     }
+    // Checked before knowing if there's anything to send, so a broken token shows up on a green run
+    // (and in dry runs) rather than on the day tests fail
+    const slack = await getSlackClient('SLACK_TOKEN_TESTS_BOT', dryRun);
 
     if (failedAssertions.length === 0) {
         return;
@@ -95,16 +97,11 @@ export const reportTestResults = async ({
         .slice(1)
         .map(({ message, runLink, actorId }) => `• ${message} --- <${runLink}|${actorId}>`);
 
-    logger.info('SLACK:', slackMessage);
+    logger.info(`${sendingLabel(dryRun)} slack message to channel ${reportSlackChannel}:`, slackMessage);
     logger.info('\tblocks:', blocks.join('\n\t\t'));
 
-    if (!reportSlackChannel) {
-        return;
-    }
-
     if (!dryRun) {
-        const slackToken = getEnvVar('SLACK_TOKEN_TESTS_BOT');
-        await sendSlackMessage(reportSlackChannel, slackMessage, blocks, slackToken);
+        await sendSlackMessage(slack, reportSlackChannel, slackMessage, blocks);
     }
 };
 

package/bin/types.ts

@@ -10,6 +10,12 @@ export interface Config {
     testFilesGlob?: string;
 }
 
+/** The changes from `fromRef` (excluded) to `toRef`, compared as trees like `git diff fromRef toRef`. */
+export interface GitRange {
+    fromRef: string;
+    toRef: string;
+}
+
 export type Commit = {
     sha: string;
     author: string;
@@ -24,6 +30,15 @@ export interface BuildData {
     buildNumber: string;
 }
 
+/**
+ * What a dry run writes to stdout instead of the command's real result. It's an object, not an array, so
+ * it can't be mistaken for real builds: `ACTOR_BUILDS` rejects it before any test runs.
+ */
+export interface DryRunPlan<T> {
+    dryRun: true;
+    builds: T[];
+}
+
 export interface ActorConfig {
     actorFullName: string;
     folder: ExistingDir;

package/dist/bin/affected-actors.d.ts

@@ -0,0 +1,46 @@
+import type { Commit } from './types.js';
+interface AffectedActorsOptions {
+    /**
+     * Base usually points to the master branch
+     * Only what HEAD changes compared to base counts, like `git diff base...HEAD` or GitHub's "Files changed" tab:
+     * the branch's own changes, not what it merged in from base.
+     */
+    base?: string;
+    /**
+     * With `base` it's the last validated commit of the branch: Actors that didn't change after it are left out.
+     * It's ignored when it is HEAD (a rerun) or isn't in the local history. Without `base` everything after it
+     * counts, and it must be an ancestor of HEAD (e.g. the last release).
+     */
+    since?: string;
+    /** Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them. */
+    testFilesGlob?: string;
+    actors: string[];
+    ignore: string[];
+}
+/** The JSON document `get-affected-actors` prints. Versioned, since other commands and workflows consume it. */
+interface AffectedActors {
+    version: 1;
+    head: string;
+    /** The commits, changed files and changelog describe the whole range, `--since` with `--base` only narrows the Actors. */
+    commits: Commit[];
+    changedFiles: string[];
+    changelog: string | null;
+    /**
+     * Actors with at least one functional change. They need a new build and tests. Only the names: the config file
+     * stays the source of truth for the rest.
+     */
+    functionallyChangedActors: {
+        actorFullName: string;
+    }[];
+    /** Actors whose changes are all cosmetic (README, CHANGELOG, cosmetic .actor JSON). They only need a release build. */
+    cosmeticallyChangedActors: {
+        actorFullName: string;
+    }[];
+}
+/**
+ * Finds the Actors whose context changed in the given range. `base` selects the branch's own changes
+ * (a PR), `since` the changes after a known commit (a release, or the last validated commit of a PR).
+ */
+export declare const getAffectedActors: ({ base, since: sinceOption, testFilesGlob, actors, ignore, }: AffectedActorsOptions) => Promise<AffectedActors>;
+export {};
+//# sourceMappingURL=affected-actors.d.ts.map

package/dist/bin/affected-actors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affected-actors.d.ts","sourceRoot":"","sources":["../../bin/affected-actors.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAe,MAAM,EAAY,MAAM,YAAY,CAAC;AAMhE,UAAU,qBAAqB;IAC3B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0GAA0G;IAC1G,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,gHAAgH;AAChH,UAAU,cAAc;IACpB,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,0HAA0H;IAC1H,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvD,uHAAuH;IACvH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC1D;AAyFD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,8DAMrC,qBAAqB,KAAG,OAAO,CAAC,cAAc,CA+ChD,CAAC"}