@featurevisor/core 0.60.1 → 0.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/core",
-  "version": "0.60.1",
+  "version": "0.62.0",
   "description": "Core package of Featurevisor for Node.js usage",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -44,9 +44,9 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@featurevisor/sdk": "^0.60.1",
-    "@featurevisor/site": "^0.60.0",
-    "@featurevisor/types": "^0.60.0",
+    "@featurevisor/sdk": "^0.62.0",
+    "@featurevisor/site": "^0.62.0",
+    "@featurevisor/types": "^0.62.0",
     "axios": "^1.3.4",
     "joi": "^17.8.3",
     "js-yaml": "^4.1.0",
@@ -57,5 +57,5 @@
     "@types/js-yaml": "^4.0.5",
     "@types/tar": "^6.1.4"
   },
-  "gitHead": "f6c5b34eb63599914cc26efadf87bbad810a89fa"
+  "gitHead": "64ff2edd5bbc0deedfc69aa2ada36b36e5e0c13a"
 }

package/src/datasource/adapter.ts

@@ -1,6 +1,12 @@
-import { DatafileContent, EnvironmentKey, ExistingState } from "@featurevisor/types";
-
-export type EntityType = "feature" | "group" | "segment" | "attribute" | "test";
+import {
+  DatafileContent,
+  EnvironmentKey,
+  ExistingState,
+  HistoryEntry,
+  Commit,
+  CommitHash,
+  EntityType,
+} from "@featurevisor/types";
 
 export interface DatafileOptions {
   environment: EnvironmentKey;
@@ -22,4 +28,12 @@ export abstract class Adapter {
   // datafile
   abstract readDatafile(options: DatafileOptions): Promise<DatafileContent>;
   abstract writeDatafile(datafileContent: DatafileContent, options: DatafileOptions): Promise<void>;
+
+  // history
+  abstract listHistoryEntries(entityType?: EntityType, entityKey?: string): Promise<HistoryEntry[]>;
+  abstract readCommit(
+    commit: CommitHash,
+    entityType?: EntityType,
+    entityKey?: string,
+  ): Promise<Commit>;
 }

package/src/datasource/datasource.ts

@@ -10,6 +10,7 @@ import {
   SegmentKey,
   AttributeKey,
   DatafileContent,
+  EntityType,
 } from "@featurevisor/types";
 
 import { ProjectConfig, CustomParser } from "../config";
@@ -19,8 +20,8 @@ import { Adapter, DatafileOptions } from "./adapter";
 export class Datasource {
   private adapter: Adapter;
 
-  constructor(private config: ProjectConfig) {
-    this.adapter = new config.adapter(config);
+  constructor(private config: ProjectConfig, private rootDirectoryPath?: string) {
+    this.adapter = new config.adapter(config, rootDirectoryPath);
   }
 
   // @TODO: only site generator needs it, find a way to get it out of here later
@@ -187,4 +188,13 @@ export class Datasource {
   getTestSpecName(testKey: string) {
     return `${testKey}.${this.getExtension()}`;
   }
+
+  // history
+  listHistoryEntries(entityType?: EntityType, entityKey?: string) {
+    return this.adapter.listHistoryEntries(entityType, entityKey);
+  }
+
+  readCommit(commitHash: string, entityType?: EntityType, entityKey?: string) {
+    return this.adapter.readCommit(commitHash, entityType, entityKey);
+  }
 }

package/src/datasource/filesystemAdapter.ts

@@ -1,12 +1,25 @@
 import * as fs from "fs";
 import * as path from "path";
+import { execSync } from "child_process";
 
 import * as mkdirp from "mkdirp";
 
-import { ExistingState, EnvironmentKey, DatafileContent } from "@featurevisor/types";
-
-import { Adapter, EntityType, DatafileOptions } from "./adapter";
+import {
+  ExistingState,
+  EnvironmentKey,
+  DatafileContent,
+  EntityType,
+  HistoryEntry,
+  Commit,
+  CommitHash,
+  HistoryEntity,
+} from "@featurevisor/types";
+
+import { Adapter, DatafileOptions } from "./adapter";
 import { ProjectConfig, CustomParser } from "../config";
+import { getCommit } from "../utils/git";
+
+const commitRegex = /^commit (\w+)\nAuthor: (.+) <(.+)>\nDate:   (.+)\n\n(.+)/gm; // eslint-disable-line
 
 export function getExistingStateFilePath(
   projectConfig: ProjectConfig,
@@ -18,7 +31,7 @@ export function getExistingStateFilePath(
 export class FilesystemAdapter extends Adapter {
   private parser: CustomParser;
 
-  constructor(private config: ProjectConfig) {
+  constructor(private config: ProjectConfig, private rootDirectoryPath?: string) {
     super();
 
     this.parser = config.parser as CustomParser;
@@ -161,4 +174,131 @@ export class FilesystemAdapter extends Adapter {
     const shortPath = outputFilePath.replace(root + path.sep, "");
     console.log(`     Datafile generated: ${shortPath}`);
   }
+
+  /**
+   * History
+   */
+  getRawHistory(pathPatterns: string[]) {
+    const gitPaths = pathPatterns.join(" ");
+
+    const logCommand = `git log --name-only --pretty=format:"%h|%an|%aI" --relative --no-merges -- ${gitPaths}`;
+    const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+
+    return execSync(fullCommand, { encoding: "utf8" }).toString();
+  }
+
+  getPathPatterns(entityType?: EntityType, entityKey?: string): string[] {
+    let pathPatterns: string[] = [];
+
+    if (entityType && entityKey) {
+      pathPatterns = [this.getEntityPath(entityType, entityKey)];
+    } else if (entityType) {
+      if (entityType === "attribute") {
+        pathPatterns = [this.config.attributesDirectoryPath];
+      } else if (entityType === "segment") {
+        pathPatterns = [this.config.segmentsDirectoryPath];
+      } else if (entityType === "feature") {
+        pathPatterns = [this.config.featuresDirectoryPath];
+      } else if (entityType === "group") {
+        pathPatterns = [this.config.groupsDirectoryPath];
+      } else if (entityType === "test") {
+        pathPatterns = [this.config.testsDirectoryPath];
+      }
+    } else {
+      pathPatterns = [
+        this.config.featuresDirectoryPath,
+        this.config.attributesDirectoryPath,
+        this.config.segmentsDirectoryPath,
+        this.config.groupsDirectoryPath,
+        this.config.testsDirectoryPath,
+      ];
+    }
+
+    return pathPatterns.map((p) => p.replace((this.rootDirectoryPath as string) + path.sep, ""));
+  }
+
+  async listHistoryEntries(entityType?: EntityType, entityKey?: string): Promise<HistoryEntry[]> {
+    const pathPatterns = this.getPathPatterns(entityType, entityKey);
+    const rawHistory = this.getRawHistory(pathPatterns);
+
+    const fullHistory: HistoryEntry[] = [];
+    const blocks = rawHistory.split("\n\n");
+
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+
+      if (block.length === 0) {
+        continue;
+      }
+
+      const lines = block.split("\n");
+
+      const commitLine = lines[0];
+      const [commitHash, author, timestamp] = commitLine.split("|");
+
+      const entities: HistoryEntity[] = [];
+
+      const filePathLines = lines.slice(1);
+      for (let j = 0; j < filePathLines.length; j++) {
+        const relativePath = filePathLines[j];
+        const absolutePath = path.join(this.rootDirectoryPath as string, relativePath);
+        const fileName = absolutePath.split(path.sep).pop() as string;
+        const relativeDir = path.dirname(absolutePath);
+
+        const key = fileName.replace("." + this.parser.extension, "");
+
+        let type: EntityType = "attribute";
+        if (relativeDir === this.config.attributesDirectoryPath) {
+          type = "attribute";
+        } else if (relativeDir === this.config.segmentsDirectoryPath) {
+          type = "segment";
+        } else if (relativeDir === this.config.featuresDirectoryPath) {
+          type = "feature";
+        } else if (relativeDir === this.config.groupsDirectoryPath) {
+          type = "group";
+        } else if (relativeDir === this.config.testsDirectoryPath) {
+          type = "test";
+        } else {
+          continue;
+        }
+
+        entities.push({
+          type,
+          key,
+        });
+      }
+
+      if (entities.length === 0) {
+        continue;
+      }
+
+      fullHistory.push({
+        commit: commitHash,
+        author,
+        timestamp,
+        entities,
+      });
+    }
+
+    return fullHistory;
+  }
+
+  async readCommit(
+    commitHash: CommitHash,
+    entityType?: EntityType,
+    entityKey?: string,
+  ): Promise<Commit> {
+    const pathPatterns = this.getPathPatterns(entityType, entityKey);
+    const gitPaths = pathPatterns.join(" ");
+    const logCommand = `git show ${commitHash} --relative -- ${gitPaths}`;
+    const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+
+    const gitShowOutput = execSync(fullCommand, { encoding: "utf8" }).toString();
+    const commit = getCommit(gitShowOutput, {
+      rootDirectoryPath: this.rootDirectoryPath as string,
+      projectConfig: this.config,
+    });
+
+    return commit;
+  }
 }

package/src/site/exportSite.ts

@@ -24,7 +24,7 @@ export async function exportSite(deps: Dependencies) {
   console.log("Site dist copied to:", projectConfig.siteExportDirectoryPath);
 
   // generate history
-  const fullHistory = generateHistory(deps);
+  const fullHistory = await generateHistory(deps);
 
   // site search index
   const repoDetails = getRepoDetails();
@@ -40,7 +40,5 @@ export async function exportSite(deps: Dependencies) {
     { recursive: true },
   );
 
-  // @TODO: replace placeoholders in index.html
-
   return hasError;
 }

package/src/site/generateHistory.ts

@@ -1,88 +1,14 @@
 import * as path from "path";
 import * as fs from "fs";
-import { execSync } from "child_process";
 
 import { HistoryEntry } from "@featurevisor/types";
-
-import { getRelativePaths } from "./getRelativePaths";
 import { Dependencies } from "../dependencies";
 
-export function generateHistory(deps: Dependencies): HistoryEntry[] {
-  const { rootDirectoryPath, projectConfig, datasource } = deps;
+export async function generateHistory(deps: Dependencies): Promise<HistoryEntry[]> {
+  const { projectConfig, datasource } = deps;
 
   try {
-    // raw history
-    const rawHistoryFilePath = path.join(projectConfig.siteExportDirectoryPath, "history-raw.txt");
-
-    const { relativeFeaturesPath, relativeSegmentsPath, relativeAttributesPath } = getRelativePaths(
-      rootDirectoryPath,
-      projectConfig,
-    );
-
-    const separator = "|";
-
-    const cmd = `git log --name-only --pretty=format:"%h${separator}%an${separator}%aI" --no-merges --relative -- ${relativeFeaturesPath} ${relativeSegmentsPath} ${relativeAttributesPath} > ${rawHistoryFilePath}`;
-    execSync(cmd);
-
-    console.log(`History (raw) generated at: ${rawHistoryFilePath}`);
-
-    // structured history
-    const rawHistory = fs.readFileSync(rawHistoryFilePath, "utf8");
-
-    const fullHistory: HistoryEntry[] = [];
-
-    let entry: HistoryEntry = {
-      commit: "",
-      author: "",
-      timestamp: "",
-      entities: [],
-    };
-
-    rawHistory.split("\n").forEach((line, index) => {
-      if (index === 0 && line.length === 0) {
-        // no history found
-        return;
-      }
-
-      if (index > 0 && line.length === 0) {
-        // commit finished
-        fullHistory.push(entry);
-
-        return;
-      }
-
-      if (line.indexOf(separator) > -1) {
-        // commit line
-        const parts = line.split("|");
-
-        entry = {
-          commit: parts[0],
-          author: parts[1],
-          timestamp: parts[2],
-          entities: [],
-        };
-      } else {
-        // file line
-        const lineSplit = line.split(path.sep);
-        const fileName = lineSplit.pop() as string;
-        const relativeDir = lineSplit.join(path.sep);
-
-        const key = fileName.replace("." + datasource.getExtension(), "");
-
-        let type = "feature" as "attribute" | "segment" | "feature";
-
-        if (relativeDir === relativeSegmentsPath) {
-          type = "segment";
-        } else if (relativeDir === relativeAttributesPath) {
-          type = "attribute";
-        }
-
-        entry.entities.push({
-          type,
-          key,
-        });
-      }
-    });
+    const fullHistory = await datasource.listHistoryEntries();
 
     const fullHistoryFilePath = path.join(
       projectConfig.siteExportDirectoryPath,

package/src/tester/testFeature.ts

@@ -14,6 +14,8 @@ export async function testFeature(
   datasource: Datasource,
   projectConfig: ProjectConfig,
   test: TestFeature,
+  options: { verbose?: boolean } = {},
+  patterns,
 ): Promise<boolean> {
   let hasError = false;
   const featureKey = test.feature;
@@ -22,9 +24,15 @@ export async function testFeature(
 
   for (let aIndex = 0; aIndex < test.assertions.length; aIndex++) {
     const assertion = test.assertions[aIndex];
-    const description = assertion.description || `at ${assertion.at}%`;
+    const description = `  Assertion #${aIndex + 1}: (${assertion.environment}) ${
+      assertion.description || `at ${assertion.at}%`
+    }`;
 
-    console.log(`  Assertion #${aIndex + 1}: (${assertion.environment}) ${description}`);
+    if (patterns.assertionPattern && !patterns.assertionPattern.test(description)) {
+      continue;
+    }
+
+    console.log(description);
 
     const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
     const featuresToInclude = Array.from(requiredChain);
@@ -47,11 +55,12 @@ export async function testFeature(
       configureBucketValue: () => {
         return assertion.at * (MAX_BUCKETED_NUMBER / 100);
       },
-      // logger: createLogger({
-      //   levels: ["debug", "info", "warn", "error"],
-      // }),
     });
 
+    if (options.verbose) {
+      sdk.setLogLevels(["debug", "info", "warn", "error"]);
+    }
+
     // isEnabled
     if ("expectedToBeEnabled" in assertion) {
       const isEnabled = sdk.isEnabled(featureKey, assertion.context);

package/src/tester/testProject.ts

@@ -7,7 +7,16 @@ import { testFeature } from "./testFeature";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
 import { Dependencies } from "../dependencies";
 
-export async function testProject(deps: Dependencies): Promise<boolean> {
+export interface TestProjectOptions {
+  keyPattern?: string;
+  assertionPattern?: string;
+  verbose?: boolean;
+}
+
+export async function testProject(
+  deps: Dependencies,
+  options: TestProjectOptions = {},
+): Promise<boolean> {
   const { rootDirectoryPath, projectConfig, datasource } = deps;
 
   let hasError = false;
@@ -28,19 +37,27 @@ export async function testProject(deps: Dependencies): Promise<boolean> {
     return hasError;
   }
 
+  const patterns = {
+    keyPattern: options.keyPattern ? new RegExp(options.keyPattern) : undefined,
+    assertionPattern: options.assertionPattern ? new RegExp(options.assertionPattern) : undefined,
+  };
+
   for (const testFile of testFiles) {
     const testFilePath = datasource.getTestSpecName(testFile);
 
-    console.log("");
-    console.log(CLI_FORMAT_BOLD, `Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);
-
     const t = await datasource.readTest(testFile);
 
     if ((t as TestSegment).segment) {
       // segment testing
       const test = t as TestSegment;
 
-      const segmentHasError = await testSegment(datasource, test);
+      if (patterns.keyPattern && !patterns.keyPattern.test(test.segment)) {
+        continue;
+      }
+
+      console.log(CLI_FORMAT_BOLD, `\nTesting: ${testFilePath.replace(rootDirectoryPath, "")}`);
+
+      const segmentHasError = await testSegment(datasource, test, patterns);
 
       if (segmentHasError) {
         hasError = true;
@@ -49,7 +66,13 @@ export async function testProject(deps: Dependencies): Promise<boolean> {
       // feature testing
       const test = t as TestFeature;
 
-      const featureHasError = await testFeature(datasource, projectConfig, test);
+      if (patterns.keyPattern && !patterns.keyPattern.test(test.feature)) {
+        continue;
+      }
+
+      console.log(CLI_FORMAT_BOLD, `\nTesting: ${testFilePath.replace(rootDirectoryPath, "")}`);
+
+      const featureHasError = await testFeature(datasource, projectConfig, test, options, patterns);
 
       if (featureHasError) {
         hasError = true;

package/src/tester/testSegment.ts

@@ -5,7 +5,11 @@ import { Datasource } from "../datasource";
 
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
 
-export async function testSegment(datasource: Datasource, test: TestSegment): Promise<boolean> {
+export async function testSegment(
+  datasource: Datasource,
+  test: TestSegment,
+  patterns,
+): Promise<boolean> {
   let hasError = false;
 
   const segmentKey = test.segment;
@@ -25,9 +29,13 @@ export async function testSegment(datasource: Datasource, test: TestSegment): Pr
   const conditions = parsedSegment.conditions as Condition | Condition[];
 
   test.assertions.forEach(function (assertion, aIndex) {
-    const description = assertion.description || `#${aIndex + 1}`;
+    const description = `  Assertion #${aIndex + 1}: ${assertion.description || `#${aIndex + 1}`}`;
 
-    console.log(`  Assertion #${aIndex + 1}: ${description}`);
+    if (patterns.assertionPattern && !patterns.assertionPattern.test(description)) {
+      return;
+    }
+
+    console.log(description);
 
     const expected = assertion.expectedToMatch;
     const actual = allConditionsAreMatched(conditions, assertion.context);

package/src/utils/git.ts

@@ -0,0 +1,129 @@
+import * as path from "path";
+
+import { Commit, EntityDiff, EntityType } from "@featurevisor/types";
+
+import { CustomParser, ProjectConfig } from "../config";
+
+function parseGitCommitShowOutput(gitShowOutput: string) {
+  const result = {
+    hash: "",
+    author: "",
+    date: "",
+    message: "",
+    diffs: {},
+  };
+
+  const lines = gitShowOutput.split("\n");
+  let currentFile = "";
+  let parsingDiffs = false;
+  let parsingMessage = false;
+
+  lines.forEach((line) => {
+    if (line.startsWith("commit ")) {
+      result.hash = line.replace("commit ", "").trim();
+    } else if (line.startsWith("Author:")) {
+      result.author = line.replace("Author:", "").trim();
+      parsingMessage = false;
+    } else if (line.startsWith("Date:")) {
+      result.date = line.replace("Date:", "").trim();
+      parsingMessage = true; // Start parsing commit message
+    } else if (line.startsWith("diff --git")) {
+      if (currentFile) {
+        // Finish capturing the previous file's diff
+        parsingDiffs = false;
+      }
+      currentFile = line.split(" ")[2].substring(2);
+      result.diffs[currentFile] = line + "\n"; // Include the diff --git line
+      parsingDiffs = true;
+      parsingMessage = false; // Stop parsing commit message
+    } else if (parsingDiffs) {
+      result.diffs[currentFile] += line + "\n";
+    } else if (parsingMessage && line.trim() !== "") {
+      result.message += line.trim() + "\n"; // Capture commit message
+    }
+  });
+
+  return result;
+}
+
+function analyzeFileChange(diff) {
+  let status = "updated"; // Default to 'updated'
+
+  // Check for file creation or deletion
+  if (diff.includes("new file mode")) {
+    status = "created";
+  } else if (diff.includes("deleted file mode")) {
+    status = "deleted";
+  }
+
+  return status;
+}
+
+export function getCommit(
+  gitShowOutput: string,
+  options: { rootDirectoryPath: string; projectConfig: ProjectConfig },
+): Commit {
+  const parsed = parseGitCommitShowOutput(gitShowOutput);
+  const { rootDirectoryPath, projectConfig } = options;
+
+  const commit: Commit = {
+    hash: parsed.hash,
+    author: parsed.author,
+    timestamp: parsed.date,
+    entities: [],
+  };
+
+  Object.keys(parsed.diffs).forEach((file) => {
+    const diff = parsed.diffs[file];
+    const status = analyzeFileChange(diff);
+
+    const absolutePath = path.join(rootDirectoryPath, file);
+    const relativeDir = path.dirname(absolutePath);
+
+    // get entity type
+    let type: EntityType = "attribute";
+    if (relativeDir === projectConfig.attributesDirectoryPath) {
+      type = "attribute";
+    } else if (relativeDir === projectConfig.segmentsDirectoryPath) {
+      type = "segment";
+    } else if (relativeDir === projectConfig.featuresDirectoryPath) {
+      type = "feature";
+    } else if (relativeDir === projectConfig.groupsDirectoryPath) {
+      type = "group";
+    } else if (relativeDir === projectConfig.testsDirectoryPath) {
+      type = "test";
+    } else {
+      // unknown type
+      return;
+    }
+
+    // get entity key
+    const fileName = absolutePath.split(path.sep).pop() as string;
+    const extensionWithDot = "." + (projectConfig.parser as CustomParser).extension;
+
+    if (!fileName.endsWith(extensionWithDot)) {
+      // unknown extension
+      return;
+    }
+
+    const key = fileName.replace(extensionWithDot, "");
+
+    const entityDiff: EntityDiff = {
+      type,
+      key,
+      content: diff,
+    };
+
+    if (status === "created") {
+      entityDiff.created = true;
+    } else if (status === "deleted") {
+      entityDiff.deleted = true;
+    } else {
+      entityDiff.updated = true;
+    }
+
+    commit.entities.push(entityDiff);
+  });
+
+  return commit;
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./extractKeys";
+export * from "./git";

package/lib/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;AAEA,SAAgB,mCAAmC,CACjD,QAAuC;IAEvC,IAAM,MAAM,GAAG,IAAI,GAAG,EAAc,CAAC;IAErC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC3B,QAAQ,CAAC,OAAO,CAAC,UAAC,OAAO;YACvB,mCAAmC,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,UAAC,UAAU;gBAC9D,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;KACJ;IAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;QAChC,IAAI,KAAK,IAAI,QAAQ,EAAE;YACrB,mCAAmC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAC,UAAU;gBACnE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,IAAI,IAAI,QAAQ,EAAE;YACpB,mCAAmC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,UAAC,UAAU;gBAClE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,KAAK,IAAI,QAAQ,EAAE;YACrB,mCAAmC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAC,UAAU;gBACnE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;SACJ;KACF;IAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;QAChC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;KACtB;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAtCD,kFAsCC;AAED,SAAgB,kCAAkC,CAChD,UAAmC;IAEnC,IAAM,MAAM,GAAG,IAAI,GAAG,EAAgB,CAAC;IAEvC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7B,UAAU,CAAC,OAAO,CAAC,UAAC,SAAS;YAC3B,kCAAkC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,UAAC,YAAY;gBACjE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;KACJ;IAED,IAAI,WAAW,IAAI,UAAU,EAAE;QAC7B,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;KAClC;IAED,IAAI,KAAK,IAAI,UAAU,EAAE;QACvB,kCAAkC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAC,YAAY;YACtE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;KACJ;IAED,IAAI,IAAI,IAAI,UAAU,EAAE;QACtB,kCAAkC,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,UAAC,YAAY;YACrE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;KACJ;IAED,IAAI,KAAK,IAAI,UAAU,EAAE;QACvB,kCAAkC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAC,YAAY;YACtE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;KACJ;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AApCD,gFAoCC"}