@platformos/platformos-graph 0.0.20 → 0.2.0

package/src/index.ts

@@ -1,5 +1,20 @@
 export { buildAppGraph } from './graph/build';
-export { extractFileReferences } from './graph/traverse';
+export { enumerateEdgeSources, isEdgeSource } from './graph/edge-sources';
+export { extractFileReferences, extractStructural } from './graph/traverse';
+export {
+  dependenciesOf,
+  dependentsOf,
+  exists,
+  isEntryPoint,
+  isOrphan,
+  orphans,
+  reachableFrom,
+  missingDependencies,
+  missingTargets,
+  nearestModules,
+} from './graph/query';
+export type { NearestModulesOptions } from './graph/query';
 export { serializeAppGraph } from './graph/serialize';
 export { parseJs, toSourceCode } from './toSourceCode';
+export { appBackedGetSourceCode, graphParsers } from './parsers';
 export * from './types';

package/src/parsers.spec.ts

@@ -0,0 +1,85 @@
+import { App, Parsers, SourceCodeType } from '@platformos/platformos-common';
+import { toLiquidHTMLAST } from '@platformos/platformos-check-common';
+import { describe, expect, it, vi } from 'vitest';
+import { appBackedGetSourceCode, graphParsers } from './parsers';
+import { toSourceCode } from './toSourceCode';
+
+const ROOT = 'file:///project';
+const uri = (relativePath: string) => `${ROOT}/${relativePath}`;
+
+const fsOver = (files: Record<string, string>) => ({
+  readFile: async (target: string) => {
+    const source = files[target];
+    if (source === undefined) throw new Error(`ENOENT: ${target}`);
+    return source;
+  },
+  stat: async () => {
+    throw new Error('not used');
+  },
+  readDirectory: async () => [],
+});
+
+describe('graphParsers', () => {
+  it('registers a JS parser and treats images as opaque', async () => {
+    const jsUri = uri('app/assets/app.js');
+    const pngUri = uri('app/assets/logo.png');
+    const files = { [jsUri]: 'export const a = 1;', [pngUri]: 'binary' };
+    const app = App.fromPaths(ROOT, [jsUri, pngUri], fsOver(files), graphParsers);
+
+    await app.load();
+
+    expect((app.get(jsUri)!.ast as { type: string }).type).toBe('Program');
+    expect(app.get(pngUri)!.ast).toEqual(new Error('File parsing not implemented'));
+  });
+
+  it('is the same JS parse the buffer path uses', async () => {
+    const source = 'export const a = 1;';
+    const jsUri = uri('app/assets/app.js');
+    const app = App.fromPaths(ROOT, [jsUri], fsOver({ [jsUri]: source }), graphParsers);
+    await app.load();
+
+    const fromBuffer = await toSourceCode(jsUri, source);
+
+    expect(app.get(jsUri)!.ast).toEqual(fromBuffer.ast);
+  });
+});
+
+describe('appBackedGetSourceCode', () => {
+  const parsers = (
+    liquid = vi.fn(toLiquidHTMLAST),
+  ): { parsers: Parsers; liquid: typeof liquid } => ({
+    parsers: { [SourceCodeType.LiquidHtml]: liquid, extensions: graphParsers.extensions },
+    liquid,
+  });
+
+  it('parses a file at most once across a graph read and a lint read', async () => {
+    const cardUri = uri('app/views/partials/card.liquid');
+    const { parsers: registered, liquid } = parsers();
+    const app = App.fromPaths(ROOT, [cardUri], fsOver({ [cardUri]: '<b>card</b>' }), registered);
+    const getSourceCode = appBackedGetSourceCode(app, async () => {
+      throw new Error('fallback should not be needed');
+    });
+
+    // The graph asks for it…
+    const forGraph = await getSourceCode(cardUri);
+    void forGraph.ast;
+    // …and the lint reads the same file object.
+    await app.get(cardUri)!.load();
+    void app.get(cardUri)!.ast;
+
+    expect(forGraph).toBe(app.get(cardUri) as unknown as typeof forGraph);
+    expect(liquid.mock.calls.length).toBe(1);
+  });
+
+  it('falls back for a URI the app does not contain', async () => {
+    const app = App.fromPaths(ROOT, [], fsOver({}), graphParsers);
+    const outside = 'file:///elsewhere/thing.liquid';
+
+    const result = await appBackedGetSourceCode(app, async (target) =>
+      toSourceCode(target, '<b>outside</b>'),
+    )(outside);
+
+    expect(result.uri).toBe(outside);
+    expect(result.source).toBe('<b>outside</b>');
+  });
+});

package/src/parsers.ts

@@ -0,0 +1,75 @@
+import { App, AppFile, Parser, Parsers, UriString } from '@platformos/platformos-common';
+import { asError } from '@platformos/platformos-check-common';
+import { parse as acornParse, Program } from 'acorn';
+
+import { FileSourceCode, SUPPORTED_ASSET_IMAGE_EXTENSIONS } from './types';
+
+/** Parse a JavaScript asset, capturing a syntax error as a value rather than throwing. */
+export function parseJs(source: string): Program | Error {
+  try {
+    return acornParse(source, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+    });
+  } catch (error) {
+    return asError(error);
+  }
+}
+
+/**
+ * A binary asset has nothing to parse. It is still a graph node — something links
+ * to it — so it gets an `Error` value rather than being absent, exactly as an
+ * unparseable file would.
+ */
+const parseOpaqueAsset: Parser = () => new Error('File parsing not implemented');
+
+/**
+ * The file types the GRAPH holds and the linter does not: `.js` assets and images.
+ *
+ * They exist for {@link toSourceCode}'s contract — every URI it is handed comes back as a
+ * `FileSourceCode` — and so an `App` an asset URI is put into can answer `ast` at all. NOT
+ * because a graph build reads them: `traverseModule` returns immediately for an Asset node, and
+ * the only question the graph asks about an asset is whether it EXISTS.
+ *
+ * Registering them on an {@link App} — rather than building a second set of file objects — is
+ * what lets a graph build and a lint run over the same project hold the SAME `AppFile`
+ * instances, so each file is read and parsed at most once for both. The language server does
+ * that; check-node builds no graph, so merging into `nodeParsers` would do nothing.
+ *
+ * THE MCP SUPERVISOR DELIBERATELY DOES NOT SHARE, and this is not a pending to-do: it builds no
+ * graph, parsing per request only the handful of files that could reference the edited one.
+ * Routing those through check-node's shared `App` would win nothing — `lintBuffers` parses the
+ * content it was HANDED and drops the app's entry on the way out — and would risk something,
+ * because that `App` carries UNSAVED buffers while its impact stage runs CONCURRENTLY with
+ * the lint.
+ */
+export const graphParsers: Parsers = {
+  extensions: {
+    js: parseJs,
+    ...Object.fromEntries(
+      SUPPORTED_ASSET_IMAGE_EXTENSIONS.map((extension) => [extension, parseOpaqueAsset]),
+    ),
+  },
+};
+
+/**
+ * A `getSourceCode` for the graph backed by an {@link App}.
+ *
+ * Pass it as `IDependencies.getSourceCode` and the graph stops parsing anything the
+ * lint has already parsed, and vice versa — they read the same file objects. Files
+ * the app does not contain fall through to `fallback`, which is how a URI outside
+ * the project (or an unclassified file) still gets a source code.
+ */
+export function appBackedGetSourceCode(
+  app: App,
+  fallback: (uri: UriString) => Promise<FileSourceCode>,
+): (uri: UriString) => Promise<FileSourceCode> {
+  return async (uri: UriString): Promise<FileSourceCode> => {
+    const file: AppFile | undefined = app.get(uri);
+    if (!file) return fallback(uri);
+    await file.load();
+    // An AppFile is structurally a SourceCode; its `ast` is typed `unknown` only
+    // because platformos-common sits below the parsers that produce ASTs.
+    return file as unknown as FileSourceCode;
+  };
+}

package/src/toSourceCode.ts

@@ -1,38 +1,38 @@
-import {
-  asError,
-  toSourceCode as tcToSourceCode,
-  UriString,
-} from '@platformos/platformos-check-common';
-import { parse as acornParse, Program } from 'acorn';
-import { AssetSourceCode, FileSourceCode, SUPPORTED_ASSET_IMAGE_EXTENSIONS } from './types';
+import { toSourceCode as tcToSourceCode, UriString } from '@platformos/platformos-check-common';
+import { sourceCodeTypeOf } from '@platformos/platformos-common';
+import { AssetSourceCode, FileSourceCode } from './types';
+import { graphParsers, parseJs } from './parsers';
 import { extname } from './utils';
 
-export function parseJs(source: string): Program | Error {
-  try {
-    return acornParse(source, {
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-    });
-  } catch (error) {
-    return asError(error);
-  }
-}
+export { parseJs };
 
+/**
+ * Build a source code for a graph node from contents already in hand.
+ *
+ * This is the path for callers with no `App`: an in-flight editor buffer, a fixture,
+ * a URI from outside the project. Callers that DO have one should pass
+ * `appBackedGetSourceCode(app, …)` as `getSourceCode` instead — that is what makes a
+ * graph build and a lint run share one parse per file rather than doing one each.
+ *
+ * The JS and image-asset parses come from {@link graphParsers}, so there is exactly
+ * one definition of how each is handled whether the file arrives through the App
+ * model or through here.
+ */
 export async function toSourceCode(uri: UriString, source: string): Promise<FileSourceCode> {
   const extension = extname(uri);
 
-  if (
-    extension === 'json' ||
-    extension === 'liquid' ||
-    extension === 'graphql' ||
-    extension === 'yml' ||
-    extension === 'yaml'
-  ) {
+  // `sourceCodeTypeOf` is the single answer to which extensions check-common
+  // parses; `.json` is the one addition, and only because `tcToSourceCode` models
+  // an unrecognised buffer as JSON for the editor (see its doc comment). Anything
+  // else is an asset, parsed — or not — by `graphParsers`.
+  if (sourceCodeTypeOf(uri) !== undefined || extension === 'json') {
     return tcToSourceCode(uri, source);
   }
 
-  const ast: Program | Error =
-    extension === 'js' ? parseJs(source) : new Error('File parsing not implemented');
+  const parse = graphParsers.extensions?.[extension];
+  const ast = (
+    parse ? parse(source, uri) : new Error('File parsing not implemented')
+  ) as AssetSourceCode['ast'];
 
   const assetSourceCode: AssetSourceCode = { type: 'asset', uri, source, ast };
   return assetSourceCode;

package/src/types.ts

@@ -10,32 +10,62 @@ import {
   GraphQLSourceCode,
   YAMLSourceCode,
 } from '@platformos/platformos-check-common';
+import type { App, AppResolver } from '@platformos/platformos-common';
 
 export interface IDependencies {
   fs: CheckDependencies['fs'];
 
   /** Optional perf improvement if you somehow have access to pre-computed source code info */
   getSourceCode?: (uri: UriString) => Promise<FileSourceCode>;
+
+  /**
+   * The {@link App} whose per-type name index answers `{% render 'ui/card' %}`,
+   * `{% function … = 'commands/create' %}`, `{% graphql … = 'user/find' %}` and
+   * `layout: application` — the same object {@link IDependencies.getSourceCode} reads through
+   * when it is `appBackedGetSourceCode`.
+   *
+   * The pairing is the point: a caller that holds an App should hand it over for BOTH, so the
+   * graph reuses the lint's parses AND its index. Without it, `DocumentsLocator` falls back to a
+   * walk-only stand-in and every reference costs a `readDirectory` per candidate directory.
+   *
+   * It cannot change the ANSWER, only what it costs: `App.findOrLocate` resolves index-first and
+   * falls through to the very walk the stand-in performs. Omit it where there is genuinely no
+   * App: a build in a worker thread, a CLI, a fixture.
+   */
+  app?: App | AppResolver;
 }
 
-export type Dependencies = Required<IDependencies>;
+/**
+ * `IDependencies` with the optional PERFORMANCE seams resolved by
+ * `augmentDependencies` — `getSourceCode` always present, `app` still optional
+ * because "no app here" is a legitimate final state, not an unaugmented one.
+ */
+export type Dependencies = Required<Omit<IDependencies, 'app'>> & Pick<IDependencies, 'app'>;
 
 export type AugmentedDependencies = Dependencies;
 
+/** Options controlling what a build/traversal computes beyond the edge graph. */
+export interface GraphBuildOptions {
+  /**
+   * Populate each {@link LiquidModule.structural} (self-structural facts) during
+   * the build, as a by-product of the parse. OFF by default: a consumer that
+   * needs one buffer's structural facts should call `extractStructural` directly
+   * (the per-file primitive), so a full graph build — e.g. the LSP's, which never
+   * reads `structural` — does not compute a fact nothing consumes.
+   */
+  includeStructural?: boolean;
+}
+
 export interface AppGraph {
   rootUri: UriString;
   entryPoints: AppModule[];
   modules: Record<UriString, AppModule>;
 }
 
-export type AppModule = LiquidModule | AssetModule | GraphQLModule;
+export type AppModule = LiquidModule | AssetModule | GraphQLModule | SchemaModule;
 
 export type FileSourceCode =
-  | LiquidSourceCode
-  | JSONSourceCode
-  | GraphQLSourceCode
-  | YAMLSourceCode
-  | AssetSourceCode;
+  LiquidSourceCode | JSONSourceCode | GraphQLSourceCode | YAMLSourceCode | AssetSourceCode;
 
 export interface SerializableGraph {
   rootUri: UriString;
@@ -49,8 +79,47 @@ export type SerializableEdge = Reference;
 
 export type SerializableNode = Pick<AppModule, 'uri' | 'type' | 'kind' | 'exists'>;
 
+/**
+ * A Liquid file's own structural declarations — a by-product of the parse the
+ * graph already does, so consumers need not re-parse the file.
+ *
+ * The usage arrays are ALWAYS present (sorted, de-duplicated): an empty array
+ * means "the file uses none", since the whole AST is analyzed — never "not
+ * extracted". The routing facts (`slug`/`layout`/`method`) are optional: an
+ * absent one means "not applicable / not declared" (e.g. a partial has no slug).
+ * `doc_params` lands in a later phase and will appear here when it does.
+ */
+export interface ModuleStructural {
+  /** Partial names rendered via `{% render %}` / `{% include %}` (the literal target names). */
+  renders_used: string[];
+  /** Operation names invoked via `{% graphql %}` (the literal target names). */
+  graphql_queries_used: string[];
+  /** Liquid filter names used anywhere in the file. */
+  filters_used: string[];
+  /** Liquid tag names used anywhere in the file. */
+  tags_used: string[];
+  /** Translation keys referenced via the `t` / `translate` filter. */
+  translation_keys: string[];
+  /** `@param` names declared in the file's `{% doc %}` block. */
+  doc_params: string[];
+  /**
+   * Effective URL slug: the frontmatter `slug` override if declared, else
+   * derived from the page's path. Present for page files only.
+   */
+  slug?: string;
+  /** Declared wrapper layout (frontmatter `layout`), when declared. */
+  layout?: string;
+  /** Declared HTTP method (frontmatter `method`), when declared. */
+  method?: string;
+}
+
 export interface LiquidModule extends IAppModule<ModuleType.Liquid> {
   kind: LiquidModuleKind;
+  /**
+   * The file's own structural declarations, populated during a full
+   * `buildAppGraph`. Absent when the file declares none of the surfaced facts.
+   */
+  structural?: ModuleStructural;
 }
 
 export interface AssetModule extends IAppModule<ModuleType.Asset> {
@@ -64,6 +133,40 @@ export interface AssetModule extends IAppModule<ModuleType.Asset> {
  */
 export interface GraphQLModule extends IAppModule<ModuleType.GraphQL> {
   kind: 'graphql';
+  /**
+   * The platformOS model tables this operation targets (from its `table`
+   * filters / `record_create` inputs) — every distinct table in document order.
+   * Populated during `buildAppGraph` traversal; always present (empty = the
+   * operation declares no table, or was never resolved on disk).
+   */
+  tables: string[];
+}
+
+/**
+ * A custom model type / schema file (`custom_model_types`/`model_schemas`/
+ * `schema` dirs — `PlatformOSFileType.Table`). A platform primitive,
+ * modeled as a neutral graph node. A leaf node — schema files have no outgoing
+ * platformOS dependencies — and not render-reachable, so it is discovered and
+ * added explicitly during a full `buildAppGraph` (never an entry point).
+ *
+ * NOTE (ADR 004): this is a neutral platform fact. The commands/queries
+ * convention and resource/CRUD completeness that build ON schemas are NOT
+ * modeled here — they live in the convention overlay.
+ */
+export interface SchemaModule extends IAppModule<ModuleType.Schema> {
+  kind: 'schema';
+  /**
+   * The schema's top-level `name:`, when declared — one per schema, unlike a GraphQL op's
+   * {@link GraphQLModule.tables}. Absent when the file declares no `name:` or could not be
+   * parsed.
+   *
+   * NOT directly joinable against those tables for a MODULE schema. The platform queries one
+   * as `modules/<module>/<name>` (`ParameterizedName`, and `records_filter_input.rb` maps the
+   * GraphQL `table` to `parameterized_name`), so a consumer must put this through
+   * `parameterizedTableName` with the file's module first. Measured: joining the raw value
+   * reported every module table in a real project as missing.
+   */
+  table?: string;
 }
 
 export interface IAppModule<T extends ModuleType> {
@@ -99,6 +202,7 @@ export const enum ModuleType {
   Liquid = 'Liquid',
   Asset = 'Asset',
   GraphQL = 'GraphQL',
+  Schema = 'Schema',
 }
 
 export const enum LiquidModuleKind {

package/src/utils/index.ts

@@ -5,7 +5,7 @@ export function unique<T>(array: T[]): T[] {
   return [...new Set(array)];
 }
 
-export function assertNever(module: never) {
+export function assertNever(module: never): never {
   throw new Error(`Unknown module type ${module}`);
 }
 

package/dist/getWebComponentMap.d.ts

@@ -1,10 +0,0 @@
-import { Dependencies, Void, WebComponentMap } from './types';
-/**
- * Find all the web component definitions from the JavaScript files in the
- * assets directory.
- *
- * From those, we'll be able to map `<custom-element-name>` to the definition in
- * the corresponding asset file.
- */
-export declare function getWebComponentMap(rootUri: string, { fs, getSourceCode }: Pick<Dependencies, 'fs' | 'getSourceCode'>): Promise<WebComponentMap>;
-export declare function findWebComponentReferences(uri: string, assetRoot: string, getSourceCode: Dependencies['getSourceCode'], result: WebComponentMap): Promise<Void>;

package/dist/getWebComponentMap.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWebComponentMap = getWebComponentMap;
-exports.findWebComponentReferences = findWebComponentReferences;
-const platformos_check_common_1 = require("@platformos/platformos-check-common");
-const acorn_walk_1 = require("acorn-walk");
-/**
- * Regular expression for web component names
- *
- * Based on the HTML specification for valid custom element names.
- *
- * https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
- */
-const wcre = /^[a-z][-.\d_a-z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]*([-][-.\d_a-z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]*)$/u;
-/**
- * Find all the web component definitions from the JavaScript files in the
- * assets directory.
- *
- * From those, we'll be able to map `<custom-element-name>` to the definition in
- * the corresponding asset file.
- */
-async function getWebComponentMap(rootUri, { fs, getSourceCode }) {
-    const webComponentDefs = new Map();
-    const assetRoot = platformos_check_common_1.path.join(rootUri, 'assets');
-    const jsFiles = await (0, platformos_check_common_1.recursiveReadDirectory)(fs, assetRoot, ([fileName]) => fileName.endsWith('.js'));
-    await Promise.all(jsFiles.map((uri) => findWebComponentReferences(uri, assetRoot, getSourceCode, webComponentDefs)));
-    return webComponentDefs;
-}
-async function findWebComponentReferences(uri, assetRoot, getSourceCode, result) {
-    const sourceCode = await getSourceCode(uri);
-    if (!uri.endsWith('.js')) {
-        return;
-    }
-    const ast = sourceCode.ast;
-    if (ast instanceof Error) {
-        return;
-    }
-    for (const node of ast.body) {
-        (0, acorn_walk_1.ancestor)(node, {
-            Literal(node, _state, ancestors) {
-                if (typeof node.value === 'string' && wcre.test(node.value)) {
-                    // Making sure we're looking at customElements.define calls
-                    const parentNode = ancestors.at(-2);
-                    if (!parentNode)
-                        return;
-                    if (parentNode.type !== 'CallExpression')
-                        return;
-                    const callee = parentNode.callee;
-                    if (callee.type !== 'MemberExpression')
-                        return;
-                    const property = callee.property;
-                    if (property.type !== 'Identifier')
-                        return;
-                    if (property.name !== 'define')
-                        return;
-                    result.set(node.value, {
-                        assetName: platformos_check_common_1.path.relative(uri, assetRoot),
-                        range: [property.start, node.end],
-                    });
-                }
-                return null;
-            },
-        });
-    }
-}
-//# sourceMappingURL=getWebComponentMap.js.map

package/dist/getWebComponentMap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getWebComponentMap.js","sourceRoot":"","sources":["../src/getWebComponentMap.ts"],"names":[],"mappings":";;AAsBA,gDAiBC;AAED,gEAuCC;AAhFD,iFAAmF;AACnF,2CAA+C;AAI/C;;;;;;GAMG;AACH,MAAM,IAAI,GACR,+UAA+U,CAAC;AAElV;;;;;;GAMG;AACI,KAAK,UAAU,kBAAkB,CACtC,OAAe,EACf,EAAE,EAAE,EAAE,aAAa,EAA8C;IAEjE,MAAM,gBAAgB,GAAoB,IAAI,GAAG,EAAE,CAAC;IACpD,MAAM,SAAS,GAAG,8BAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,MAAM,IAAA,gDAAsB,EAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,CACzE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CACzB,CAAC;IAEF,MAAM,OAAO,CAAC,GAAG,CACf,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAClB,0BAA0B,CAAC,GAAG,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAC5E,CACF,CAAC;IAEF,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAEM,KAAK,UAAU,0BAA0B,CAC9C,GAAW,EACX,SAAiB,EACjB,aAA4C,EAC5C,MAAuB;IAEvB,MAAM,UAAU,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;IAC5C,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;IACT,CAAC;IAED,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;IAC3B,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;QACzB,OAAO;IACT,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAA,qBAAK,EAAC,IAAI,EAAE;YACV,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS;gBAC7B,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC5D,2DAA2D;oBAC3D,MAAM,UAAU,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;oBACpC,IAAI,CAAC,UAAU;wBAAE,OAAO;oBACxB,IAAI,UAAU,CAAC,IAAI,KAAK,gBAAgB;wBAAE,OAAO;oBACjD,MAAM,MAAM,GAAI,UAA6B,CAAC,MAAM,CAAC;oBACrD,IAAI,MAAM,CAAC,IAAI,KAAK,kBAAkB;wBAAE,OAAO;oBAC/C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;oBACjC,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY;wBAAE,OAAO;oBAC3C,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ;wBAAE,OAAO;oBAEvC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE;wBACrB,SAAS,EAAE,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;wBACxC,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC;qBAClC,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC;SACF,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}