oidc-spa 8.1.10 → 8.1.12

package/src/vendor/build-runtime/magic-string.ts

@@ -0,0 +1,3 @@
+import MagicString from "magic-string";
+
+export { MagicString };

package/src/vite-plugin/detectProjectType.ts

@@ -0,0 +1,20 @@
+export type ProjectType = "tanstack-start" | "react-router-framework" | "other";
+
+type ResolvedConfigLike = {
+    plugins: readonly { name: string }[];
+};
+
+export function detectProjectType(params: { resolvedConfig: ResolvedConfigLike }): ProjectType {
+    const { resolvedConfig } = params;
+    const pluginNames = new Set(resolvedConfig.plugins.map(plugin => plugin.name));
+
+    if (pluginNames.has("tanstack-react-start:config")) {
+        return "tanstack-start";
+    }
+
+    if (pluginNames.has("react-router")) {
+        return "react-router-framework";
+    }
+
+    return "other";
+}

package/src/vite-plugin/excludeModuleExportFromOptimizedDeps.ts

@@ -0,0 +1,20 @@
+import type { UserConfig } from "vite";
+import { getThisCodebaseRootDirPath } from "../tools/getThisCodebaseRootDirPath_cjs";
+import * as fs from "node:fs";
+import { join as pathJoin } from "path";
+
+export function excludeModuleExportFromOptimizedDeps(params: { userConfig: UserConfig }): UserConfig {
+    const { userConfig } = params;
+
+    const packageJsonParsed = JSON.parse(
+        fs.readFileSync(pathJoin(getThisCodebaseRootDirPath(), "package.json")).toString("utf8")
+    ) as { name: string; exports: Record<string, { module?: string }> };
+
+    const modules = Object.entries(packageJsonParsed.exports)
+        .filter(([, value]) => value.module !== undefined)
+        .map(([key]) => key.replace(/^\./, packageJsonParsed.name));
+
+    ((userConfig.optimizeDeps ??= {}).exclude ??= []).push(...modules);
+
+    return userConfig;
+}

package/src/vite-plugin/handleClientEntrypoint.ts

@@ -0,0 +1,260 @@
+import type { OidcSpaVitePluginParams } from "./vite-plugin";
+import type { ResolvedConfig } from "vite";
+import type { PluginContext } from "rollup";
+import { detectProjectType, ProjectType } from "./detectProjectType";
+import { existsSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
+import { assert } from "../tools/tsafe/assert";
+import type { Equals } from "../tools/tsafe/Equals";
+
+type EntryResolution = {
+    absolutePath: string;
+    normalizedPath: string;
+    watchFiles: string[];
+};
+
+const ORIGINAL_QUERY_PARAM = "oidc-spa-original";
+
+const GENERIC_ENTRY_CANDIDATES = ["src/main.tsx", "src/main.ts", "src/main.jsx", "src/main.js"];
+
+const REACT_ROUTER_ENTRY_CANDIDATES = [
+    "entry.client.tsx",
+    "entry.client.ts",
+    "entry.client.jsx",
+    "entry.client.js"
+];
+
+const TANSTACK_ENTRY_CANDIDATES = ["client.tsx", "client.ts", "client.jsx", "client.js"];
+
+export function createLoadHandleEntrypoint(params: {
+    oidcSpaVitePluginParams: OidcSpaVitePluginParams;
+    resolvedConfig: ResolvedConfig;
+}) {
+    const { oidcSpaVitePluginParams, resolvedConfig } = params;
+
+    const projectType = detectProjectType({ resolvedConfig });
+
+    const entryResolution = resolveEntryForProject({
+        config: resolvedConfig,
+        projectType
+    });
+
+    async function loadHandleEntrypoint(params: {
+        id: string;
+        pluginContext: PluginContext;
+    }): Promise<null | string> {
+        const { id, pluginContext } = params;
+        const { path: rawPath, queryParams } = splitId(id);
+        const normalizedRequestPath = normalizeRequestPath(rawPath);
+        if (!normalizedRequestPath) {
+            return null;
+        }
+
+        if (normalizedRequestPath !== entryResolution.normalizedPath) {
+            return null;
+        }
+
+        const isOriginalRequest = queryParams.getAll(ORIGINAL_QUERY_PARAM).includes("true");
+
+        if (isOriginalRequest) {
+            return loadOriginalModule(entryResolution, pluginContext);
+        }
+
+        entryResolution.watchFiles.forEach(file => pluginContext.addWatchFile(file));
+
+        const {
+            freezeFetch = true,
+            freezeXMLHttpRequest = true,
+            freezeWebSocket = true,
+            ...rest
+        } = oidcSpaVitePluginParams ?? {};
+
+        assert<Equals<typeof rest, {}>>;
+
+        const stubSourceCache = [
+            `import { oidcEarlyInit } from "oidc-spa/entrypoint";`,
+            projectType === "tanstack-start" &&
+                `import { preventConsoleLoggingOfUnifiedClientRetryForSsrLoadersError } from "oidc-spa/react-tanstack-start/rfcUnifiedClientRetryForSsrLoaders/entrypoint";`,
+            `const { shouldLoadApp } = oidcEarlyInit({`,
+            `    freezeFetch: ${freezeFetch},`,
+            `    freezeXMLHttpRequest: ${freezeXMLHttpRequest},`,
+            `    freezeWebSocket: ${freezeWebSocket},`,
+            `    isPostLoginRedirectManual: ${projectType === "tanstack-start"}`,
+            `});`,
+            ``,
+            `if(shouldLoadApp){`,
+            projectType === "tanstack-start" &&
+                `    preventConsoleLoggingOfUnifiedClientRetryForSsrLoadersError();`,
+            `    import("./${path.basename(
+                entryResolution.absolutePath
+            )}?${ORIGINAL_QUERY_PARAM}=true");`,
+            `}`
+        ]
+            .filter(line => typeof line === "string")
+            .join("\n");
+
+        return stubSourceCache;
+    }
+
+    return loadHandleEntrypoint;
+}
+
+function resolveEntryForProject({
+    config,
+    projectType
+}: {
+    config: ResolvedConfig;
+    projectType: ProjectType;
+}): EntryResolution {
+    const root = config.root;
+
+    switch (projectType) {
+        case "tanstack-start": {
+            const candidate = resolveCandidate({
+                root,
+                subDirectories: ["src"],
+                filenames: TANSTACK_ENTRY_CANDIDATES
+            });
+
+            const entryPath =
+                candidate ??
+                resolvePackageFile("@tanstack/react-start", [
+                    "dist",
+                    "plugin",
+                    "default-entry",
+                    "client.tsx"
+                ]);
+
+            const normalized = normalizeAbsolute(entryPath);
+
+            const resolution: EntryResolution = {
+                absolutePath: entryPath,
+                normalizedPath: normalized,
+                watchFiles: candidate ? [entryPath] : []
+            };
+
+            return resolution;
+        }
+
+        case "react-router-framework": {
+            const candidate = resolveCandidate({
+                root,
+                subDirectories: ["app"],
+                filenames: REACT_ROUTER_ENTRY_CANDIDATES
+            });
+
+            const entryPath =
+                candidate ??
+                resolvePackageFile("@react-router/dev", [
+                    "dist",
+                    "config",
+                    "defaults",
+                    "entry.client.tsx"
+                ]);
+
+            const normalized = normalizeAbsolute(entryPath);
+
+            const resolution: EntryResolution = {
+                absolutePath: entryPath,
+                normalizedPath: normalized,
+                watchFiles: candidate ? [entryPath] : []
+            };
+
+            return resolution;
+        }
+
+        case "other": {
+            const candidate = resolveCandidate({
+                root,
+                subDirectories: ["."],
+                filenames: GENERIC_ENTRY_CANDIDATES
+            });
+
+            assert(candidate !== undefined);
+
+            const normalized = normalizeAbsolute(candidate);
+
+            const resolution: EntryResolution = {
+                absolutePath: candidate,
+                normalizedPath: normalized,
+                watchFiles: [candidate]
+            };
+
+            return resolution;
+        }
+
+        default:
+            assert<Equals<typeof projectType, never>>(false);
+    }
+}
+
+function loadOriginalModule(
+    entry: EntryResolution,
+    context: { addWatchFile(id: string): void }
+): Promise<string> {
+    entry.watchFiles.forEach(file => context.addWatchFile(file));
+    return fs.readFile(entry.absolutePath, "utf8");
+}
+
+function resolveCandidate({
+    root,
+    subDirectories,
+    filenames
+}: {
+    root: string;
+    subDirectories: string[];
+    filenames: string[];
+}): string | undefined {
+    for (const subDirectory of subDirectories) {
+        for (const filename of filenames) {
+            const candidate = path.resolve(root, subDirectory, filename);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+
+function resolvePackageFile(packageName: string, segments: string[]): string {
+    const pkgPath = require.resolve(`${packageName}/package.json`);
+    return path.resolve(path.dirname(pkgPath), ...segments);
+}
+
+function normalizeAbsolute(filePath: string): string {
+    return normalizePath(filePath);
+}
+
+function splitId(id: string): { path: string; queryParams: URLSearchParams } {
+    const queryIndex = id.indexOf("?");
+    if (queryIndex === -1) {
+        return { path: id, queryParams: new URLSearchParams() };
+    }
+
+    const pathPart = id.slice(0, queryIndex);
+    const queryString = id.slice(queryIndex + 1);
+    return { path: pathPart, queryParams: new URLSearchParams(queryString) };
+}
+
+function normalizeRequestPath(id: string): string {
+    let requestPath = id;
+
+    if (requestPath.startsWith("\0")) {
+        requestPath = requestPath.slice(1);
+    }
+
+    if (requestPath.startsWith("/@fs/")) {
+        requestPath = requestPath.slice("/@fs/".length);
+    } else if (requestPath.startsWith("file://")) {
+        requestPath = fileURLToPath(requestPath);
+    }
+
+    if (path.isAbsolute(requestPath) || requestPath.startsWith(".")) {
+        return normalizePath(requestPath);
+    }
+
+    return normalizePath(requestPath);
+}

package/src/vite-plugin/index.ts

@@ -0,0 +1 @@
+export { oidcSpa } from "./vite-plugin";

package/src/vite-plugin/transformCreateFileRoute.ts

@@ -0,0 +1,240 @@
+import { MagicString } from "../vendor/build-runtime/magic-string";
+import { babelParser, babelTraverse, babelTypes as t } from "../vendor/build-runtime/babel";
+
+const ENABLE_IMPORT_SPECIFIER = "enableUnifiedClientRetryForSsrLoaders";
+const ENABLE_IMPORT_SOURCE = "oidc-spa/react-tanstack-start/rfcUnifiedClientRetryForSsrLoaders";
+const CREATE_FILE_ROUTE_IDENTIFIER = "createFileRoute";
+const POST_LOGIN_IMPORT_SPECIFIER = "withHandlingOidcPostLoginNavigation";
+const POST_LOGIN_IMPORT_SOURCE = "oidc-spa/react-tanstack-start";
+
+type TransformParams = {
+    code: string;
+    id: string;
+};
+
+type TransformResult = {
+    code: string;
+    map: any;
+};
+
+export function transformCreateFileRoute(params: TransformParams): TransformResult | null {
+    const { code, id } = params;
+    const cleanId = sanitizeId(id);
+
+    if (!isCandidateFile(cleanId)) {
+        return null;
+    }
+
+    let ast: ReturnType<typeof babelParser.parse>;
+    try {
+        ast = babelParser.parse(code, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"]
+        });
+    } catch {
+        return null;
+    }
+
+    const magicString = new MagicString(code);
+    let hasCreateFileRouteImport = false;
+    let hasEnableImport = false;
+    let hasPostLoginImport = false;
+    let requiresEnableImport = false;
+    let requiresPostLoginImport = false;
+    let lastImportEnd: number | undefined;
+    let mutated = false;
+
+    babelTraverse(ast, {
+        ImportDeclaration(path) {
+            const sourceValue = path.node.source.value;
+            if (typeof sourceValue !== "string") {
+                return;
+            }
+
+            const end = path.node.end ?? undefined;
+            if (typeof end === "number") {
+                lastImportEnd = lastImportEnd === undefined ? end : Math.max(lastImportEnd, end);
+            }
+
+            if (sourceValue === "@tanstack/react-router") {
+                if (
+                    path.node.specifiers.some(
+                        specifier =>
+                            t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported, { name: CREATE_FILE_ROUTE_IDENTIFIER })
+                    )
+                ) {
+                    hasCreateFileRouteImport = true;
+                }
+            }
+
+            if (sourceValue === ENABLE_IMPORT_SOURCE) {
+                if (
+                    path.node.specifiers.some(
+                        specifier =>
+                            t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported, { name: ENABLE_IMPORT_SPECIFIER })
+                    )
+                ) {
+                    hasEnableImport = true;
+                }
+            }
+
+            if (sourceValue === POST_LOGIN_IMPORT_SOURCE) {
+                if (
+                    path.node.specifiers.some(
+                        specifier =>
+                            t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported, { name: POST_LOGIN_IMPORT_SPECIFIER })
+                    )
+                ) {
+                    hasPostLoginImport = true;
+                }
+            }
+        },
+        CallExpression(path) {
+            const callee = path.get("callee");
+            if (!callee.isCallExpression()) {
+                return;
+            }
+
+            const innerCallee = callee.get("callee");
+            if (!innerCallee.isIdentifier({ name: CREATE_FILE_ROUTE_IDENTIFIER })) {
+                return;
+            }
+
+            const args = path.get("arguments");
+            if (args.length === 0) {
+                return;
+            }
+
+            const configArg = args[0];
+            if (!configArg.isObjectExpression()) {
+                return;
+            }
+
+            const configNode = configArg.node;
+            let localMutated = false;
+
+            if (objectContainsLoaderOrBeforeLoad(configNode)) {
+                const start = configNode.start ?? undefined;
+                const end = configNode.end ?? undefined;
+
+                if (typeof start === "number" && typeof end === "number") {
+                    magicString.appendLeft(start, `${ENABLE_IMPORT_SPECIFIER}(`);
+                    magicString.appendRight(end, ")");
+                    requiresEnableImport = true;
+                    localMutated = true;
+                }
+            }
+
+            const innerArgs = callee.node.arguments ?? [];
+            const isRootRoute =
+                innerArgs.length > 0 && t.isStringLiteral(innerArgs[0]) && innerArgs[0].value === "/";
+
+            if (isRootRoute) {
+                const componentProp = findComponentProperty(configNode);
+                if (componentProp) {
+                    const valueNode = componentProp.value as t.Expression;
+
+                    if (!isWrappedWithHandling(valueNode)) {
+                        const start = valueNode.start ?? undefined;
+                        const end = valueNode.end ?? undefined;
+
+                        if (typeof start === "number" && typeof end === "number") {
+                            const original = code.slice(start, end);
+                            magicString.overwrite(
+                                start,
+                                end,
+                                `${POST_LOGIN_IMPORT_SPECIFIER}(${original})`
+                            );
+                            requiresPostLoginImport = true;
+                            localMutated = true;
+                        }
+                    }
+                }
+            }
+
+            if (localMutated) {
+                mutated = true;
+            }
+        }
+    });
+
+    if (!mutated || !hasCreateFileRouteImport) {
+        return null;
+    }
+
+    const importStatements: string[] = [];
+
+    if (requiresEnableImport && !hasEnableImport) {
+        importStatements.push(`import { ${ENABLE_IMPORT_SPECIFIER} } from "${ENABLE_IMPORT_SOURCE}";`);
+    }
+
+    if (requiresPostLoginImport && !hasPostLoginImport) {
+        importStatements.push(
+            `import { ${POST_LOGIN_IMPORT_SPECIFIER} } from "${POST_LOGIN_IMPORT_SOURCE}";`
+        );
+    }
+
+    if (importStatements.length > 0) {
+        const insertionPoint = lastImportEnd ?? 0;
+        const prefix = insertionPoint === 0 ? "" : "\n";
+        const suffix = "\n";
+        magicString.appendLeft(insertionPoint, `${prefix}${importStatements.join("\n")}${suffix}`);
+    }
+
+    return {
+        code: magicString.toString(),
+        map: magicString.generateMap({ hires: true, source: cleanId })
+    };
+}
+
+function findComponentProperty(node: t.ObjectExpression): t.ObjectProperty | undefined {
+    return node.properties.find(
+        prop =>
+            t.isObjectProperty(prop) &&
+            ((t.isIdentifier(prop.key) && prop.key.name === "component") ||
+                (t.isStringLiteral(prop.key) && prop.key.value === "component"))
+    ) as t.ObjectProperty | undefined;
+}
+
+function objectContainsLoaderOrBeforeLoad(node: t.ObjectExpression): boolean {
+    return node.properties.some(prop => {
+        if (!t.isObjectProperty(prop)) {
+            return false;
+        }
+
+        const key = prop.key;
+        if (t.isIdentifier(key)) {
+            return key.name === "loader" || key.name === "beforeLoad";
+        }
+
+        if (t.isStringLiteral(key)) {
+            return key.value === "loader" || key.value === "beforeLoad";
+        }
+
+        return false;
+    });
+}
+
+function isWrappedWithHandling(node: t.Node): boolean {
+    return (
+        t.isCallExpression(node) && t.isIdentifier(node.callee, { name: POST_LOGIN_IMPORT_SPECIFIER })
+    );
+}
+
+function isCandidateFile(id: string): boolean {
+    if (id.includes("node_modules")) {
+        return false;
+    }
+    return /\.(?:ts|tsx|js|jsx)$/.test(id);
+}
+
+function sanitizeId(id: string): string {
+    const queryIndex = id.indexOf("?");
+    if (queryIndex === -1) {
+        return id;
+    }
+    return id.slice(0, queryIndex);
+}

package/src/vite-plugin/vite-plugin.ts

@@ -0,0 +1,54 @@
+import type { Plugin } from "vite";
+import { assert } from "../tools/tsafe/assert";
+import type { Param0 } from "../tools/tsafe/Param0";
+import type { oidcEarlyInit } from "../entrypoint";
+import { createLoadHandleEntrypoint } from "./handleClientEntrypoint";
+import { excludeModuleExportFromOptimizedDeps } from "./excludeModuleExportFromOptimizedDeps";
+import { transformCreateFileRoute } from "./transformCreateFileRoute";
+
+export type OidcSpaVitePluginParams = Omit<Param0<typeof oidcEarlyInit>, "isPostLoginRedirectManual">;
+
+export function oidcSpa(params: OidcSpaVitePluginParams) {
+    let loadHandleEntrypoint: ReturnType<typeof createLoadHandleEntrypoint> | undefined = undefined;
+
+    const plugin: Plugin = {
+        name: "oidc-spa",
+        enforce: "pre",
+        config(userConfig) {
+            userConfig = excludeModuleExportFromOptimizedDeps({ userConfig });
+            return userConfig;
+        },
+        configResolved(resolvedConfig) {
+            loadHandleEntrypoint = createLoadHandleEntrypoint({
+                oidcSpaVitePluginParams: params,
+                resolvedConfig
+            });
+        },
+        transform(code, id) {
+            const transformed = transformCreateFileRoute({
+                code,
+                id
+            });
+
+            return transformed;
+        },
+        async load(id) {
+            assert(loadHandleEntrypoint !== undefined);
+
+            {
+                const r = await loadHandleEntrypoint({
+                    id,
+                    pluginContext: this
+                });
+
+                if (r !== null) {
+                    return r;
+                }
+            }
+
+            return null;
+        }
+    };
+
+    return plugin;
+}

package/tools/GetterOrDirectValue.d.ts

@@ -0,0 +1 @@
+export type GetterOrDirectValue<P, T> = ((params: P) => T) | T;

package/tools/GetterOrDirectValue.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=GetterOrDirectValue.js.map

package/tools/GetterOrDirectValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetterOrDirectValue.js","sourceRoot":"","sources":["../src/tools/GetterOrDirectValue.ts"],"names":[],"mappings":""}

package/tools/ZodSchemaLike.d.ts

@@ -0,0 +1,3 @@
+export type ZodSchemaLike<Input, Output> = {
+    parse: (input: Input) => Output;
+};

package/tools/ZodSchemaLike.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ZodSchemaLike.js.map

package/tools/ZodSchemaLike.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZodSchemaLike.js","sourceRoot":"","sources":["../src/tools/ZodSchemaLike.ts"],"names":[],"mappings":""}

package/tools/getThisCodebaseRootDirPath_cjs.d.ts

@@ -0,0 +1,2 @@
+export declare function getThisCodebaseRootDirPath(): string;
+export declare function getNearestPackageJsonDirPath(dirPath: string): string;

package/tools/getThisCodebaseRootDirPath_cjs.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThisCodebaseRootDirPath = getThisCodebaseRootDirPath;
+exports.getNearestPackageJsonDirPath = getNearestPackageJsonDirPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let result = undefined;
+function getThisCodebaseRootDirPath() {
+    if (result !== undefined) {
+        return result;
+    }
+    return (result = getNearestPackageJsonDirPath(__dirname));
+}
+function getNearestPackageJsonDirPath(dirPath) {
+    if (fs.existsSync(path.join(dirPath, "package.json"))) {
+        return dirPath;
+    }
+    return getNearestPackageJsonDirPath(path.join(dirPath, ".."));
+}
+//# sourceMappingURL=getThisCodebaseRootDirPath_cjs.js.map

package/tools/getThisCodebaseRootDirPath_cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getThisCodebaseRootDirPath_cjs.js","sourceRoot":"","sources":["../src/tools/getThisCodebaseRootDirPath_cjs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,gEAMC;AAED,oEAKC;AAlBD,uCAAyB;AACzB,2CAA6B;AAE7B,IAAI,MAAM,GAAuB,SAAS,CAAC;AAE3C,SAAgB,0BAA0B;IACtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,OAAO,CAAC,MAAM,GAAG,4BAA4B,CAAC,SAAS,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,SAAgB,4BAA4B,CAAC,OAAe;IACxD,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC;QACpD,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;AAClE,CAAC"}