@tyndall/core 0.0.1

package/dist/config.js

@@ -0,0 +1,552 @@
+import { access, readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { HyperError } from "./errors.js";
+const CONFIG_FILES = [
+    "hyper.config.ts",
+    "hyper.config.mjs",
+    "hyper.config.js",
+    "hyper.config.cjs",
+    "hyper.config.json",
+];
+const defaultConfig = {
+    mode: "ssg",
+    ssr: false,
+    outDir: "dist",
+    basePath: "",
+    assetsDir: "assets",
+    publicDir: "public",
+    routesDir: "src/pages",
+    jsxRuntime: "automatic",
+    target: "es2017",
+    build: {
+        version: "",
+    },
+    lint: { tool: "biome" },
+    format: { tool: "biome" },
+    plugins: [],
+    ssrAdapters: ["node"],
+    revalidateDefault: false,
+    dev: {
+        onDemandRoutes: true,
+        prewarmRoutes: [],
+    },
+    ui: {
+        adapter: "react",
+        options: {},
+    },
+    render: {
+        mode: "auto",
+    },
+    routing: {
+        nestedLayouts: true,
+        routeGroups: true,
+        routeMeta: true,
+        navigation: "url",
+        clientRender: "payload",
+        ssrClientRouting: false,
+    },
+    cache: {
+        enabled: true,
+        dir: ".hyper/cache",
+        maxSizeMB: 2048,
+        maxAgeDays: 30,
+        propsTTLSeconds: false,
+        renderCache: true,
+        chunkCache: true,
+    },
+    testing: {
+        e2e: {
+            enabled: false,
+            defaultMode: "dev",
+            headless: true,
+            retry: 0,
+            reporters: ["console"],
+        },
+    },
+    logging: {
+        level: "info",
+    },
+    modules: {
+        dynamicManifest: {
+            enabled: false,
+            program: {
+                integrityRequired: true,
+                allow: [],
+                timeoutMs: 50,
+                memoryMb: 32,
+            },
+        },
+    },
+    engine: {
+        build: "bun",
+        runtime: "node",
+    },
+    bundler: "bun",
+    transpile: "typescript-native",
+    legacy: {
+        enabled: false,
+        polyfills: "auto",
+        chunking: "auto",
+        test: false,
+    },
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assertKnownKeys = (value, allowed, path) => {
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new HyperError("CONFIG_UNKNOWN_KEY", `Unknown config key: ${path}${key}`, {
+                path: `${path}${key}`,
+            });
+        }
+    }
+};
+const expectType = (value, typeName, path) => {
+    throw new HyperError("CONFIG_INVALID", `Invalid config value at ${path}: expected ${typeName}`, {
+        path,
+        expected: typeName,
+    });
+};
+const ensureString = (value, path) => {
+    if (typeof value !== "string") {
+        return expectType(value, "string", path);
+    }
+    return value;
+};
+const ensureBoolean = (value, path) => {
+    if (typeof value !== "boolean") {
+        return expectType(value, "boolean", path);
+    }
+    return value;
+};
+const ensureNumber = (value, path) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return expectType(value, "number", path);
+    }
+    return value;
+};
+const ensureStringArray = (value, path) => {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        return expectType(value, "string[]", path);
+    }
+    return value;
+};
+const ensureEnum = (value, allowed, path) => {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        return expectType(value, allowed.join(" | "), path);
+    }
+    return value;
+};
+const ensureNumberOrFalse = (value, path) => {
+    if (value === false) {
+        return false;
+    }
+    return ensureNumber(value, path);
+};
+const loadConfigFile = async (cwd) => {
+    // Important: config resolution must be deterministic to avoid environment-specific behavior.
+    for (const file of CONFIG_FILES) {
+        const candidate = join(cwd, file);
+        try {
+            await access(candidate);
+        }
+        catch {
+            continue;
+        }
+        const extension = extname(candidate);
+        if (extension === ".json") {
+            const raw = await readFile(candidate, "utf-8");
+            return JSON.parse(raw);
+        }
+        const module = await import(pathToFileURL(candidate).href);
+        return module.default ?? module;
+    }
+    return {};
+};
+export const loadConfig = async (cwd) => {
+    const rawConfig = await loadConfigFile(cwd);
+    if (!isRecord(rawConfig)) {
+        throw new Error("Config must export an object.");
+    }
+    return resolveConfig(rawConfig);
+};
+const resolveConfig = (rawConfig) => {
+    // Merge defaults first so optional blocks get full shape before overrides apply.
+    const resolved = {
+        ...defaultConfig,
+        dev: { ...defaultConfig.dev },
+        ui: { ...defaultConfig.ui },
+        render: { ...defaultConfig.render },
+        routing: { ...defaultConfig.routing },
+        build: { ...defaultConfig.build },
+        cache: { ...defaultConfig.cache },
+        testing: { e2e: { ...defaultConfig.testing.e2e } },
+        logging: { ...defaultConfig.logging },
+        engine: { ...defaultConfig.engine },
+        lint: { ...defaultConfig.lint },
+        format: { ...defaultConfig.format },
+        legacy: { ...defaultConfig.legacy },
+    };
+    const rootKeys = new Set([
+        "mode",
+        "ssr",
+        "outDir",
+        "basePath",
+        "assetsDir",
+        "publicDir",
+        "routesDir",
+        "jsxRuntime",
+        "target",
+        "build",
+        "lint",
+        "format",
+        "plugins",
+        "ssrAdapters",
+        "revalidateDefault",
+        "dev",
+        "ui",
+        "render",
+        "routing",
+        "cache",
+        "testing",
+        "logging",
+        "modules",
+        "engine",
+        "bundler",
+        "transpile",
+        "legacy",
+    ]);
+    // Critical: fail fast on unknown keys to avoid silent misconfiguration.
+    assertKnownKeys(rawConfig, rootKeys, "");
+    if ("mode" in rawConfig) {
+        resolved.mode = ensureEnum(rawConfig.mode, ["ssg", "ssr"], "mode");
+    }
+    if ("ssr" in rawConfig) {
+        resolved.ssr = ensureBoolean(rawConfig.ssr, "ssr");
+    }
+    if ("outDir" in rawConfig) {
+        resolved.outDir = ensureString(rawConfig.outDir, "outDir");
+    }
+    if ("basePath" in rawConfig) {
+        resolved.basePath = ensureString(rawConfig.basePath, "basePath");
+    }
+    if ("assetsDir" in rawConfig) {
+        resolved.assetsDir = ensureString(rawConfig.assetsDir, "assetsDir");
+    }
+    if ("publicDir" in rawConfig) {
+        resolved.publicDir = ensureString(rawConfig.publicDir, "publicDir");
+    }
+    if ("routesDir" in rawConfig) {
+        resolved.routesDir = ensureString(rawConfig.routesDir, "routesDir");
+    }
+    if ("jsxRuntime" in rawConfig) {
+        resolved.jsxRuntime = ensureEnum(rawConfig.jsxRuntime, ["classic", "automatic"], "jsxRuntime");
+    }
+    if ("target" in rawConfig) {
+        resolved.target = ensureString(rawConfig.target, "target");
+    }
+    if ("build" in rawConfig) {
+        if (!isRecord(rawConfig.build)) {
+            expectType(rawConfig.build, "object", "build");
+        }
+        const build = rawConfig.build;
+        assertKnownKeys(build, new Set(["version"]), "build.");
+        if ("version" in build) {
+            resolved.build.version = ensureString(build.version, "build.version");
+        }
+    }
+    if ("lint" in rawConfig) {
+        if (!isRecord(rawConfig.lint)) {
+            expectType(rawConfig.lint, "object", "lint");
+        }
+        const lint = rawConfig.lint;
+        if ("tool" in lint) {
+            resolved.lint.tool = ensureEnum(lint.tool, ["biome", "eslint"], "lint.tool");
+        }
+        resolved.lint = { ...resolved.lint, ...lint };
+    }
+    if ("format" in rawConfig) {
+        if (!isRecord(rawConfig.format)) {
+            expectType(rawConfig.format, "object", "format");
+        }
+        const format = rawConfig.format;
+        if ("tool" in format) {
+            resolved.format.tool = ensureEnum(format.tool, ["biome", "eslint", "prettier"], "format.tool");
+        }
+        resolved.format = { ...resolved.format, ...format };
+    }
+    if ("plugins" in rawConfig) {
+        if (!Array.isArray(rawConfig.plugins)) {
+            expectType(rawConfig.plugins, "Plugin[]", "plugins");
+        }
+        resolved.plugins = rawConfig.plugins;
+    }
+    if ("ssrAdapters" in rawConfig) {
+        const adapters = ensureStringArray(rawConfig.ssrAdapters, "ssrAdapters");
+        const allowed = new Set(["node", "express", "fastify"]);
+        for (const adapter of adapters) {
+            if (!allowed.has(adapter)) {
+                throw new Error(`Invalid config value at ssrAdapters: ${adapter}`);
+            }
+        }
+        resolved.ssrAdapters = adapters;
+    }
+    if ("revalidateDefault" in rawConfig) {
+        resolved.revalidateDefault = ensureNumberOrFalse(rawConfig.revalidateDefault, "revalidateDefault");
+    }
+    if ("dev" in rawConfig) {
+        if (!isRecord(rawConfig.dev)) {
+            expectType(rawConfig.dev, "object", "dev");
+        }
+        const dev = rawConfig.dev;
+        assertKnownKeys(dev, new Set(["onDemandRoutes", "prewarmRoutes"]), "dev.");
+        if ("onDemandRoutes" in dev) {
+            resolved.dev.onDemandRoutes = ensureBoolean(dev.onDemandRoutes, "dev.onDemandRoutes");
+        }
+        if ("prewarmRoutes" in dev) {
+            resolved.dev.prewarmRoutes = ensureStringArray(dev.prewarmRoutes, "dev.prewarmRoutes");
+        }
+    }
+    if ("ui" in rawConfig) {
+        if (!isRecord(rawConfig.ui)) {
+            expectType(rawConfig.ui, "object", "ui");
+        }
+        const ui = rawConfig.ui;
+        assertKnownKeys(ui, new Set(["adapter", "options"]), "ui.");
+        if ("adapter" in ui) {
+            if (typeof ui.adapter !== "string" && typeof ui.adapter !== "function") {
+                expectType(ui.adapter, "string | UIAdapterFactory", "ui.adapter");
+            }
+            resolved.ui.adapter = ui.adapter;
+        }
+        if ("options" in ui) {
+            if (!isRecord(ui.options)) {
+                expectType(ui.options, "object", "ui.options");
+            }
+            resolved.ui.options = ui.options;
+        }
+    }
+    if ("render" in rawConfig) {
+        if (!isRecord(rawConfig.render)) {
+            expectType(rawConfig.render, "object", "render");
+        }
+        const render = rawConfig.render;
+        assertKnownKeys(render, new Set(["mode"]), "render.");
+        if ("mode" in render) {
+            resolved.render.mode = ensureEnum(render.mode, ["ssg", "ssr", "auto"], "render.mode");
+        }
+    }
+    if ("routing" in rawConfig) {
+        if (!isRecord(rawConfig.routing)) {
+            expectType(rawConfig.routing, "object", "routing");
+        }
+        const routing = rawConfig.routing;
+        assertKnownKeys(routing, new Set([
+            "nestedLayouts",
+            "routeGroups",
+            "routeMeta",
+            "navigation",
+            "clientRender",
+            "ssrClientRouting",
+        ]), "routing.");
+        if ("nestedLayouts" in routing) {
+            resolved.routing.nestedLayouts = ensureBoolean(routing.nestedLayouts, "routing.nestedLayouts");
+        }
+        if ("routeGroups" in routing) {
+            resolved.routing.routeGroups = ensureBoolean(routing.routeGroups, "routing.routeGroups");
+        }
+        if ("routeMeta" in routing) {
+            resolved.routing.routeMeta = ensureBoolean(routing.routeMeta, "routing.routeMeta");
+        }
+        if ("navigation" in routing) {
+            resolved.routing.navigation = ensureEnum(routing.navigation, ["url", "client"], "routing.navigation");
+        }
+        if ("clientRender" in routing) {
+            resolved.routing.clientRender = ensureEnum(routing.clientRender, ["payload", "module"], "routing.clientRender");
+        }
+        if ("ssrClientRouting" in routing) {
+            resolved.routing.ssrClientRouting = ensureBoolean(routing.ssrClientRouting, "routing.ssrClientRouting");
+        }
+    }
+    if ("cache" in rawConfig) {
+        if (!isRecord(rawConfig.cache)) {
+            expectType(rawConfig.cache, "object", "cache");
+        }
+        const cache = rawConfig.cache;
+        assertKnownKeys(cache, new Set([
+            "enabled",
+            "dir",
+            "maxSizeMB",
+            "maxAgeDays",
+            "propsTTLSeconds",
+            "renderCache",
+            "chunkCache",
+        ]), "cache.");
+        if ("enabled" in cache) {
+            resolved.cache.enabled = ensureBoolean(cache.enabled, "cache.enabled");
+        }
+        if ("dir" in cache) {
+            resolved.cache.dir = ensureString(cache.dir, "cache.dir");
+        }
+        if ("maxSizeMB" in cache) {
+            resolved.cache.maxSizeMB = ensureNumber(cache.maxSizeMB, "cache.maxSizeMB");
+        }
+        if ("maxAgeDays" in cache) {
+            resolved.cache.maxAgeDays = ensureNumber(cache.maxAgeDays, "cache.maxAgeDays");
+        }
+        if ("propsTTLSeconds" in cache) {
+            resolved.cache.propsTTLSeconds = ensureNumberOrFalse(cache.propsTTLSeconds, "cache.propsTTLSeconds");
+        }
+        if ("renderCache" in cache) {
+            resolved.cache.renderCache = ensureBoolean(cache.renderCache, "cache.renderCache");
+        }
+        if ("chunkCache" in cache) {
+            resolved.cache.chunkCache = ensureBoolean(cache.chunkCache, "cache.chunkCache");
+        }
+    }
+    if ("testing" in rawConfig) {
+        if (!isRecord(rawConfig.testing)) {
+            expectType(rawConfig.testing, "object", "testing");
+        }
+        const testing = rawConfig.testing;
+        assertKnownKeys(testing, new Set(["e2e"]), "testing.");
+        if ("e2e" in testing) {
+            if (!isRecord(testing.e2e)) {
+                expectType(testing.e2e, "object", "testing.e2e");
+            }
+            const e2e = testing.e2e;
+            assertKnownKeys(e2e, new Set(["enabled", "defaultMode", "headless", "retry", "reporters", "environmentScript"]), "testing.e2e.");
+            if ("enabled" in e2e) {
+                resolved.testing.e2e.enabled = ensureBoolean(e2e.enabled, "testing.e2e.enabled");
+            }
+            if ("defaultMode" in e2e) {
+                resolved.testing.e2e.defaultMode = ensureEnum(e2e.defaultMode, ["dev", "ssg", "ssr"], "testing.e2e.defaultMode");
+            }
+            if ("headless" in e2e) {
+                resolved.testing.e2e.headless = ensureBoolean(e2e.headless, "testing.e2e.headless");
+            }
+            if ("retry" in e2e) {
+                const retry = ensureNumber(e2e.retry, "testing.e2e.retry");
+                if (retry < 0) {
+                    throw new HyperError("CONFIG_INVALID", "Invalid config value at testing.e2e.retry: must be >= 0", { path: "testing.e2e.retry", expected: "number >= 0" });
+                }
+                resolved.testing.e2e.retry = retry;
+            }
+            if ("reporters" in e2e) {
+                const reporters = ensureStringArray(e2e.reporters, "testing.e2e.reporters");
+                const allowed = new Set(["console", "json", "html"]);
+                for (const reporter of reporters) {
+                    if (!allowed.has(reporter)) {
+                        throw new Error(`Invalid config value at testing.e2e.reporters: ${reporter}`);
+                    }
+                }
+                resolved.testing.e2e.reporters = reporters;
+            }
+            if ("environmentScript" in e2e) {
+                resolved.testing.e2e.environmentScript = ensureString(e2e.environmentScript, "testing.e2e.environmentScript");
+            }
+        }
+    }
+    if ("logging" in rawConfig) {
+        if (!isRecord(rawConfig.logging)) {
+            expectType(rawConfig.logging, "object", "logging");
+        }
+        const logging = rawConfig.logging;
+        assertKnownKeys(logging, new Set(["level"]), "logging.");
+        if ("level" in logging) {
+            resolved.logging.level = ensureEnum(logging.level, ["fatal", "error", "warn", "info"], "logging.level");
+        }
+    }
+    if ("modules" in rawConfig) {
+        if (!isRecord(rawConfig.modules)) {
+            expectType(rawConfig.modules, "object", "modules");
+        }
+        const modules = rawConfig.modules;
+        assertKnownKeys(modules, new Set(["dynamicManifest"]), "modules.");
+        if ("dynamicManifest" in modules) {
+            if (!isRecord(modules.dynamicManifest)) {
+                expectType(modules.dynamicManifest, "object", "modules.dynamicManifest");
+            }
+            const dynamicManifest = modules.dynamicManifest;
+            assertKnownKeys(dynamicManifest, new Set(["enabled", "program"]), "modules.dynamicManifest.");
+            if ("enabled" in dynamicManifest) {
+                resolved.modules.dynamicManifest.enabled = ensureBoolean(dynamicManifest.enabled, "modules.dynamicManifest.enabled");
+            }
+            if ("program" in dynamicManifest) {
+                if (!isRecord(dynamicManifest.program)) {
+                    expectType(dynamicManifest.program, "object", "modules.dynamicManifest.program");
+                }
+                const program = dynamicManifest.program;
+                assertKnownKeys(program, new Set(["integrityRequired", "allow", "timeoutMs", "memoryMb"]), "modules.dynamicManifest.program.");
+                if ("integrityRequired" in program) {
+                    resolved.modules.dynamicManifest.program.integrityRequired = ensureBoolean(program.integrityRequired, "modules.dynamicManifest.program.integrityRequired");
+                }
+                if ("allow" in program) {
+                    resolved.modules.dynamicManifest.program.allow = ensureStringArray(program.allow, "modules.dynamicManifest.program.allow");
+                }
+                if ("timeoutMs" in program) {
+                    resolved.modules.dynamicManifest.program.timeoutMs = ensureNumber(program.timeoutMs, "modules.dynamicManifest.program.timeoutMs");
+                }
+                if ("memoryMb" in program) {
+                    resolved.modules.dynamicManifest.program.memoryMb = ensureNumber(program.memoryMb, "modules.dynamicManifest.program.memoryMb");
+                }
+            }
+        }
+    }
+    if ("engine" in rawConfig) {
+        // Important: allow both shorthand string and object form for engine overrides.
+        const engine = rawConfig.engine;
+        if (typeof engine === "string") {
+            resolved.engine.build = ensureEnum(engine, ["bun", "node"], "engine");
+        }
+        else if (isRecord(engine)) {
+            assertKnownKeys(engine, new Set(["runtime", "build"]), "engine.");
+            if ("build" in engine) {
+                resolved.engine.build = ensureEnum(engine.build, ["bun", "node"], "engine.build");
+            }
+            if ("runtime" in engine) {
+                resolved.engine.runtime = ensureEnum(engine.runtime, ["bun", "node"], "engine.runtime");
+            }
+        }
+        else {
+            expectType(engine, "'bun' | 'node' | object", "engine");
+        }
+    }
+    if ("bundler" in rawConfig) {
+        resolved.bundler = ensureEnum(rawConfig.bundler, ["bun", "esbuild", "swc"], "bundler");
+    }
+    if ("transpile" in rawConfig) {
+        resolved.transpile = ensureEnum(rawConfig.transpile, ["typescript-native", "tsc"], "transpile");
+    }
+    if ("legacy" in rawConfig) {
+        if (!isRecord(rawConfig.legacy)) {
+            expectType(rawConfig.legacy, "object", "legacy");
+        }
+        const legacy = rawConfig.legacy;
+        assertKnownKeys(legacy, new Set(["enabled", "polyfills", "chunking", "test"]), "legacy.");
+        if ("enabled" in legacy) {
+            resolved.legacy.enabled = ensureBoolean(legacy.enabled, "legacy.enabled");
+        }
+        if ("polyfills" in legacy) {
+            if (legacy.polyfills !== "auto" && !Array.isArray(legacy.polyfills)) {
+                expectType(legacy.polyfills, "'auto' | string[]", "legacy.polyfills");
+            }
+            if (Array.isArray(legacy.polyfills)) {
+                resolved.legacy.polyfills = ensureStringArray(legacy.polyfills, "legacy.polyfills");
+            }
+            else {
+                resolved.legacy.polyfills = legacy.polyfills;
+            }
+        }
+        if ("chunking" in legacy) {
+            if (legacy.chunking !== "auto" && legacy.chunking !== "safe") {
+                expectType(legacy.chunking, "'auto' | 'safe'", "legacy.chunking");
+            }
+            resolved.legacy.chunking = legacy.chunking;
+        }
+        if ("test" in legacy) {
+            resolved.legacy.test = ensureBoolean(legacy.test, "legacy.test");
+        }
+    }
+    return resolved;
+};

package/dist/dynamic-manifest.d.ts

@@ -0,0 +1,78 @@
+export type DynamicPageMode = "meta" | "program";
+export interface DynamicPageCache {
+    ttlSeconds?: number;
+    etag?: string;
+    swrSeconds?: number;
+}
+export interface DynamicPagePolicy {
+    render?: "csr" | "ssr" | "redirect" | "auto";
+    auth?: string;
+    seo?: string;
+    headers?: Record<string, string>;
+    redirect?: string;
+    [key: string]: unknown;
+}
+export interface MetaNode {
+    type: string;
+    props?: Record<string, unknown>;
+    children?: Array<MetaNode | string>;
+}
+export interface MetaDefinition {
+    kind: "meta";
+    root: MetaNode;
+}
+export interface ProgramDefinition {
+    kind: "program";
+    entry: {
+        code: string;
+    };
+    integrity?: {
+        alg?: string;
+        signature?: string;
+    };
+    sandbox?: {
+        timeoutMs?: number;
+        memoryMb?: number;
+    };
+}
+export type DynamicPageDefinition = MetaDefinition | ProgramDefinition;
+export interface DynamicPageEnvelope {
+    pageId: string;
+    version: string | number;
+    mode: DynamicPageMode;
+    cache?: DynamicPageCache;
+    policy?: DynamicPagePolicy;
+    pageProps?: Record<string, unknown>;
+    definition: DynamicPageDefinition;
+}
+export declare const dynamicManifestSchema: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly type: "object";
+    readonly required: readonly ["pageId", "version", "mode", "definition"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly pageId: {
+            readonly type: "string";
+        };
+        readonly version: {
+            readonly type: readonly ["string", "number"];
+        };
+        readonly mode: {
+            readonly enum: readonly ["meta", "program"];
+        };
+        readonly cache: {
+            readonly type: "object";
+        };
+        readonly policy: {
+            readonly type: "object";
+        };
+        readonly pageProps: {
+            readonly type: "object";
+        };
+        readonly definition: {
+            readonly type: "object";
+        };
+    };
+};
+export declare const validateDynamicManifest: (input: unknown) => DynamicPageEnvelope;
+//# sourceMappingURL=dynamic-manifest.d.ts.map

package/dist/dynamic-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-manifest.d.ts","sourceRoot":"","sources":["../src/dynamic-manifest.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,SAAS,CAAC,EAAE;QACV,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAEvE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcxB,CAAC;AA+NX,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,mBAmCxD,CAAC"}