@ykdz/template 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YKDZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @ykdz/template
+
+Project template generator for YKDZ starter projects.
+
+## Usage
+
+```sh
+pnpm dlx @ykdz/template init my-project --preset ts-lib --yes
+```
+
+Available commands:
+
+```sh
+template init <dir> --preset <name> --yes
+template add package --preset <name> --name <name>
+template presets
+template schema preset
+template schema blueprint
+template preset validate <path>
+template blueprint validate <path>
+```
+
+Supported presets are `ts-lib`, `hono-api`, `vue-app`, `vue-hono-app`, and
+`rust-bin`.
+
+## Publishing
+
+This package is intended to publish through npm Trusted Publishing from the
+GitHub Actions release workflow. Maintainers should complete
+[the Trusted Publishing checklist](docs/npm-trusted-publishing.md) before the
+first public release.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

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

package/dist/cli.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { initHonoApiProject } from "./hono-api.js";
+import { initRustBinProject } from "./rust-bin.js";
+import { initTsLibProject } from "./ts-lib.js";
+import { initVueHonoAppProject } from "./vue-hono-app.js";
+import { initVueAppProject } from "./vue-app.js";
+import { addPackage } from "./package-addition.js";
+import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint } from "./declarations.js";
+function usage() {
+    return [
+        "Usage:",
+        "  template init <dir> --preset <name> --yes",
+        "  template add package --preset <name> --name <name>",
+        "  template presets",
+        "  template schema preset",
+        "  template schema blueprint",
+        "  template preset validate <path>",
+        "  template blueprint validate <path>",
+        "",
+        "Options:",
+        "  --preset <name>  Project preset to generate",
+        "  --name <name>    Package name to add",
+        "  --scope <name>   Package scope for workspace package names",
+        "  --yes            Accept defaults for non-interactive generation",
+        "  --dry-run        Print the planned generation without writing files",
+        "  --json           Print machine-readable output"
+    ].join("\n");
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+async function readJsonDeclaration(filePath) {
+    if (path.extname(filePath) !== ".json") {
+        throw new Error(`Declaration files must be JSON: ${filePath}`);
+    }
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function formatValidationIssues(issues) {
+    return issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n");
+}
+function formatPresetCatalog() {
+    return [
+        "Built-in presets",
+        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`)
+    ].join("\n");
+}
+function parseInitOptions(args) {
+    const dir = args[1];
+    let preset = "";
+    let yes = false;
+    let dryRun = false;
+    let json = false;
+    let scope;
+    for (let index = 2; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--yes" || arg === "-y") {
+            yes = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--scope") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--scope requires a value");
+            }
+            scope = normalizeNpmScope(value);
+            index += 1;
+            continue;
+        }
+        if (arg === "--preset") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--preset requires a value");
+            }
+            preset = value;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option: ${arg}`);
+    }
+    if (!dir) {
+        throw new Error("init requires a target directory");
+    }
+    return { dir, preset, yes, dryRun, json, scope };
+}
+function normalizeNpmScope(value) {
+    if (value !== value.trim() || /\s/.test(value)) {
+        throw new Error("--scope must be a valid npm scope without whitespace");
+    }
+    const scope = value.startsWith("@") ? value.slice(1) : value;
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(scope)) {
+        throw new Error("--scope must be a valid npm scope");
+    }
+    return scope;
+}
+function supportedPreset(name) {
+    const preset = builtInPresets.find((candidate) => candidate.name === name && candidate.generation === "supported");
+    if (!preset) {
+        throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+    }
+    return preset;
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function scopeFromOptions(projectName, scope) {
+    return scope ?? projectName;
+}
+function blueprintForInit(options) {
+    const preset = supportedPreset(options.preset);
+    const projectName = projectNameFromDir(options.dir);
+    const packageScope = scopeFromOptions(projectName, options.scope);
+    const blueprint = {
+        schemaVersion: 1,
+        preset: preset.name,
+        projectKind: preset.supportedProjectKinds[0],
+        features: [...preset.features]
+    };
+    if (preset.supportedPackageManagers[0]) {
+        blueprint.packageManager = preset.supportedPackageManagers[0];
+    }
+    if (preset.name === "vue-hono-app") {
+        blueprint.packages = [
+            { name: `@${packageScope}/web`, path: "apps/web" },
+            { name: `@${packageScope}/api`, path: "apps/api" }
+        ];
+    }
+    return blueprint;
+}
+function formatBlueprintSummary(targetDir, blueprint) {
+    const lines = [
+        "Project Blueprint",
+        `  Target: ${targetDir}`,
+        `  Preset: ${blueprint.preset}`,
+        `  Project kind: ${blueprint.projectKind}`
+    ];
+    if (blueprint.packageManager) {
+        lines.push(`  Package manager: ${blueprint.packageManager}`);
+    }
+    if (blueprint.packages) {
+        lines.push("  Packages:");
+        for (const pkg of blueprint.packages) {
+            lines.push(`    - ${pkg.name} (${pkg.path})`);
+        }
+    }
+    lines.push(`  Features: ${blueprint.features.join(", ")}`);
+    return lines.join("\n");
+}
+function nextStepsForPreset(preset) {
+    if (preset === "rust-bin") {
+        return ["cd <target>", "./scripts/check"];
+    }
+    return ["cd <target>", "pnpm install", "pnpm run check"];
+}
+function formatNextSteps(targetDir, preset) {
+    return [
+        "Next steps:",
+        ...nextStepsForPreset(preset).map((step) => `  ${step.replace("<target>", targetDir)}`)
+    ].join("\n");
+}
+function printInitComplete(options, blueprint) {
+    const preset = blueprint.preset;
+    if (options.json) {
+        printJson({
+            command: "init",
+            dryRun: false,
+            targetDir: options.dir,
+            blueprint,
+            nextSteps: nextStepsForPreset(preset).map((step) => step.replace("<target>", options.dir))
+        });
+        return;
+    }
+    console.log(`Initialized ${options.preset} project in ${options.dir}`);
+    console.log(formatNextSteps(options.dir, preset));
+}
+function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function confirmInit(targetDir, blueprint) {
+    console.log(formatBlueprintSummary(targetDir, blueprint));
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        const answer = await readline.question("Generate this project? [y/N] ");
+        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+    }
+    finally {
+        readline.close();
+    }
+}
+function parseAddPackageOptions(args) {
+    let preset = "";
+    let name = "";
+    for (let index = 2; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--preset") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--preset requires a value");
+            }
+            preset = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--name") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--name requires a value");
+            }
+            name = value;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option: ${arg}`);
+    }
+    if (!preset) {
+        throw new Error("add package requires --preset");
+    }
+    if (!name) {
+        throw new Error("add package requires --name");
+    }
+    return { preset, name };
+}
+async function main(args) {
+    const command = args[0];
+    if (command === "presets") {
+        console.log(formatPresetCatalog());
+        return;
+    }
+    if (command === "schema") {
+        const schemaName = args[1];
+        if (schemaName === "preset") {
+            printJson(presetFileJsonSchema);
+            return;
+        }
+        if (schemaName === "blueprint") {
+            printJson(blueprintJsonSchema);
+            return;
+        }
+        throw new Error("schema requires preset or blueprint");
+    }
+    if (command === "preset" && args[1] === "validate") {
+        const filePath = args[2];
+        if (!filePath) {
+            throw new Error("preset validate requires a path");
+        }
+        const result = validatePresetFile(await readJsonDeclaration(filePath));
+        if (!result.ok) {
+            throw new Error(`Preset file is invalid:\n${formatValidationIssues(result.issues)}`);
+        }
+        console.log(`Preset file is valid: ${result.value.name}`);
+        return;
+    }
+    if (command === "blueprint" && args[1] === "validate") {
+        const filePath = args[2];
+        if (!filePath) {
+            throw new Error("blueprint validate requires a path");
+        }
+        const result = validateProjectBlueprint(await readJsonDeclaration(filePath));
+        if (!result.ok) {
+            throw new Error(`Blueprint is invalid:\n${formatValidationIssues(result.issues)}`);
+        }
+        console.log(`Blueprint is valid: ${result.value.preset}`);
+        return;
+    }
+    if (command === "init") {
+        const options = parseInitOptions(args);
+        const blueprint = blueprintForInit(options);
+        if (options.dryRun) {
+            if (options.json) {
+                printJson({
+                    command: "init",
+                    dryRun: true,
+                    targetDir: options.dir,
+                    blueprint
+                });
+                return;
+            }
+            console.log(formatBlueprintSummary(options.dir, blueprint));
+            return;
+        }
+        if (!options.yes && (options.json || !isInteractiveTerminal())) {
+            throw new Error("Non-interactive init requires --yes");
+        }
+        if (!options.yes && !(await confirmInit(options.dir, blueprint))) {
+            throw new Error("Init cancelled");
+        }
+        if (options.preset === "ts-lib") {
+            await initTsLibProject(options.dir);
+            printInitComplete(options, blueprint);
+            return;
+        }
+        if (options.preset === "hono-api") {
+            await initHonoApiProject(options.dir);
+            printInitComplete(options, blueprint);
+            return;
+        }
+        if (options.preset === "vue-app") {
+            await initVueAppProject(options.dir);
+            printInitComplete(options, blueprint);
+            return;
+        }
+        if (options.preset === "vue-hono-app") {
+            await initVueHonoAppProject(options.dir, { scope: options.scope });
+            printInitComplete(options, blueprint);
+            return;
+        }
+        if (options.preset === "rust-bin") {
+            await initRustBinProject(options.dir);
+            printInitComplete(options, blueprint);
+            return;
+        }
+        throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+    }
+    if (command === "add" && args[1] === "package") {
+        const options = parseAddPackageOptions(args);
+        await addPackage({ cwd: process.cwd(), preset: options.preset, name: options.name });
+        console.log(`Added ${options.preset} package ${options.name}`);
+        return;
+    }
+    if (command === "--help" || command === "-h") {
+        console.log(usage());
+        return;
+    }
+    throw new Error(command ? `Unknown command: ${command}` : "Missing command");
+}
+main(process.argv.slice(2)).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    console.error("");
+    console.error(usage());
+    process.exitCode = 1;
+});

package/dist/declarations.d.ts

@@ -0,0 +1,166 @@
+import * as v from "valibot";
+export type PresetName = "ts-lib" | "hono-api" | "vue-app" | "vue-hono-app" | "rust-bin" | "ts-app" | "node-cli";
+export type BuiltInPreset = {
+    name: PresetName;
+    title: string;
+    description: string;
+    generation: "supported" | "future";
+    supportedPackageManagers: readonly PackageManager[];
+    supportedProjectKinds: readonly ProjectKind[];
+    features: readonly FeatureName[];
+};
+export type PackageManager = "pnpm";
+export type ProjectKind = "single-package" | "multi-package";
+export type FeatureName = "pnpm-catalog" | "oxc-format-lint" | "strict-typescript" | "root-check" | "fix-command" | "devcontainer" | "github-actions" | "dependabot" | "rustfmt-clippy" | "cargo-test" | "native-binary-release";
+export type PresetFile = {
+    schemaVersion: 1;
+    name: string;
+    title: string;
+    description: string;
+    supportedPackageManagers: PackageManager[];
+    supportedProjectKinds: ProjectKind[];
+    features: FeatureName[];
+};
+export type ProjectPackage = {
+    name: string;
+    path: string;
+};
+export type ProjectBlueprint = {
+    schemaVersion: 1;
+    preset: string;
+    packageManager?: PackageManager;
+    projectKind: ProjectKind;
+    features: FeatureName[];
+    packages?: ProjectPackage[];
+};
+export declare const builtInPresets: readonly BuiltInPreset[];
+export declare const presetFileJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://ykdz.dev/schemas/project-kit/preset-file.schema.json";
+    readonly title: "Project Kit Preset File";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "name", "title", "description", "supportedPackageManagers", "supportedProjectKinds", "features"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly supportedPackageManagers: {
+            readonly type: "array";
+            readonly items: {
+                readonly enum: readonly ["pnpm"];
+            };
+            readonly uniqueItems: true;
+        };
+        readonly supportedProjectKinds: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly enum: readonly ["single-package", "multi-package"];
+            };
+            readonly uniqueItems: true;
+        };
+        readonly features: {
+            readonly type: "array";
+            readonly items: {
+                readonly enum: FeatureName[];
+            };
+            readonly uniqueItems: true;
+        };
+    };
+};
+export declare const blueprintJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://ykdz.dev/schemas/project-kit/blueprint.schema.json";
+    readonly title: "Project Kit Blueprint";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "preset", "projectKind", "features"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: 1;
+        };
+        readonly preset: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly packageManager: {
+            readonly enum: readonly ["pnpm"];
+        };
+        readonly projectKind: {
+            readonly enum: readonly ["single-package", "multi-package"];
+        };
+        readonly features: {
+            readonly type: "array";
+            readonly items: {
+                readonly enum: FeatureName[];
+            };
+            readonly uniqueItems: true;
+        };
+        readonly packages: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["name", "path"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly path: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const presetFileSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<1, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly supportedPackageManagers: v.ArraySchema<v.PicklistSchema<["pnpm"], undefined>, undefined>;
+    readonly supportedProjectKinds: v.SchemaWithPipe<readonly [v.ArraySchema<v.PicklistSchema<["single-package", "multi-package"], undefined>, undefined>, v.MinLengthAction<("single-package" | "multi-package")[], 1, undefined>]>;
+    readonly features: v.ArraySchema<v.PicklistSchema<FeatureName[], undefined>, undefined>;
+}, undefined>;
+export declare const projectBlueprintSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<1, undefined>;
+    readonly preset: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly packageManager: v.OptionalSchema<v.PicklistSchema<["pnpm"], undefined>, undefined>;
+    readonly projectKind: v.PicklistSchema<["single-package", "multi-package"], undefined>;
+    readonly features: v.ArraySchema<v.PicklistSchema<FeatureName[], undefined>, undefined>;
+    readonly packages: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type ValidationIssue = {
+    path: string;
+    message: string;
+};
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: ValidationIssue[];
+};
+export declare function validatePresetFile(input: unknown): ValidationResult<PresetFile>;
+export declare function findBuiltInPreset(name: string): BuiltInPreset | undefined;
+export declare function validateProjectBlueprint(input: unknown): ValidationResult<ProjectBlueprint>;
+//# sourceMappingURL=declarations.d.ts.map

package/dist/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../src/declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,UAAU,GACV,SAAS,GACT,cAAc,GACd,UAAU,GACV,QAAQ,GACR,UAAU,CAAC;AAEf,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,WAAW,GAAG,QAAQ,CAAC;IACnC,wBAAwB,EAAE,SAAS,cAAc,EAAE,CAAC;IACpD,qBAAqB,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,WAAW,GACnB,cAAc,GACd,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,GACZ,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,YAAY,GACZ,gBAAgB,GAChB,YAAY,GACZ,uBAAuB,CAAC;AAE5B,MAAM,MAAM,UAAU,GAAG;IACvB,aAAa,EAAE,CAAC,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,wBAAwB,EAAE,cAAc,EAAE,CAAC;IAC3C,qBAAqB,EAAE,WAAW,EAAE,CAAC;IACrC,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,aAAa,EA4GlD,CAAC;AAgBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCvB,CAAC;AAEX,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BtB,CAAC;AAOX,eAAO,MAAM,gBAAgB;;;;;;;;aAQ3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;aAcjC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAC1B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAgD7C,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAAC,UAAU,CAAC,CA2B/E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEzE;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,gBAAgB,CAAC,gBAAgB,CAAC,CAqFpC"}