@fluojs/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/commands/scripts.js

@@ -0,0 +1,570 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
+const EMPTY_ENV = {};
+const FAILURE_STDOUT_BUFFER_LIMIT = 16_384;
+const PRETTY_TTY_COLOR_ENV = 'FLUO_DEV_PRETTY_TTY_COLOR';
+const PRETTY_CHILD_OUTPUT_PREFIX = 'app │ ';
+const SHOW_NODE_RESTART_NOTICE_ENV = 'FLUO_DEV_SHOW_RESTART_NOTICE';
+function getCliSourceRoot() {
+  return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function getCliEntryPoint() {
+  return join(getCliSourceRoot(), 'cli.js');
+}
+function getPreserveColorTtyImport() {
+  return join(getCliSourceRoot(), 'dev-runner', 'preserve-color-tty.js');
+}
+function isRecord(value) {
+  return typeof value === 'object' && value !== null;
+}
+function readJsonFile(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    return isRecord(parsed) ? parsed : undefined;
+  } catch (_error) {
+    return undefined;
+  }
+}
+function findProjectManifest(startDirectory) {
+  let current = resolve(startDirectory);
+  while (true) {
+    const candidate = join(current, 'package.json');
+    if (existsSync(candidate)) {
+      const manifest = readJsonFile(candidate);
+      if (manifest) {
+        return {
+          directory: current,
+          manifest,
+          path: candidate
+        };
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+function hasManifestDependency(manifest, packageName) {
+  for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+    const entries = manifest[field];
+    if (isRecord(entries) && typeof entries[packageName] === 'string') {
+      return true;
+    }
+  }
+  return false;
+}
+function detectProjectRuntime(manifest) {
+  if (hasManifestDependency(manifest, '@fluojs/platform-bun')) {
+    return 'bun';
+  }
+  if (hasManifestDependency(manifest, '@fluojs/platform-deno')) {
+    return 'deno';
+  }
+  if (hasManifestDependency(manifest, '@fluojs/platform-cloudflare-workers')) {
+    return 'cloudflare-workers';
+  }
+  return 'node';
+}
+function withDefaultNodeEnv(env, defaultNodeEnv) {
+  if (env.NODE_ENV) {
+    return {
+      ...env
+    };
+  }
+  return {
+    ...env,
+    NODE_ENV: defaultNodeEnv
+  };
+}
+function findPathEnvKey(env) {
+  return Object.keys(env).find(key => key.toLowerCase() === 'path') ?? 'PATH';
+}
+function withProjectLocalBin(env, projectDirectory) {
+  const pathKey = findPathEnvKey(env);
+  const existingPath = env[pathKey];
+  const localBin = join(projectDirectory, 'node_modules', '.bin');
+  return {
+    ...env,
+    [pathKey]: existingPath ? `${localBin}${delimiter}${existingPath}` : localBin
+  };
+}
+function withPipedReporterColorEnv(env, mode, stdout, stderr) {
+  if (!(mode === 'app' || mode === 'pretty') || env.NO_COLOR !== undefined) {
+    return env;
+  }
+  if (!stdout.isTTY || !stderr.isTTY) {
+    return env;
+  }
+  return {
+    ...env,
+    FORCE_COLOR: env.FORCE_COLOR ?? '1',
+    [PRETTY_TTY_COLOR_ENV]: '1'
+  };
+}
+function defaultSpawnCommand(command, args, options) {
+  return new Promise((resolveExitCode, reject) => {
+    const child = spawn(command, args, options);
+    if (options.stdio === 'pipe') {
+      child.stdout?.on('data', chunk => options.stdout?.write(String(chunk)));
+      child.stderr?.on('data', chunk => options.stderr?.write(String(chunk)));
+    }
+    child.on('error', reject);
+    child.on('close', code => resolveExitCode(code ?? 1));
+  });
+}
+function buildNativeNodeWatchStep(passThrough) {
+  return {
+    command: 'node',
+    args: ['--env-file=.env', '--watch', '--watch-preserve-output', '--import', 'tsx', 'src/main.ts', ...passThrough],
+    mode: 'native-watch'
+  };
+}
+function buildFluoDevRunnerStep(runtime, passThrough) {
+  return {
+    command: 'node',
+    args: ['--import', 'tsx', getCliEntryPoint(), '__dev-runner', '--runtime', runtime, '--', ...passThrough],
+    mode: 'fluo-restart'
+  };
+}
+function buildNativeRuntimeDevStep(runtime, passThrough) {
+  switch (runtime) {
+    case 'node':
+      return buildNativeNodeWatchStep(passThrough);
+    case 'bun':
+      return {
+        command: 'bun',
+        args: ['--watch', 'src/main.ts', ...passThrough],
+        mode: 'runtime-native-watch'
+      };
+    case 'deno':
+      return {
+        command: 'deno',
+        args: ['run', '--watch', '--allow-env', '--allow-net', 'src/main.ts', ...passThrough],
+        mode: 'runtime-native-watch'
+      };
+    case 'cloudflare-workers':
+      return {
+        command: 'wrangler',
+        args: ['dev', '--show-interactive-dev-session=false', ...passThrough],
+        mode: 'runtime-native-watch'
+      };
+    default:
+      return undefined;
+  }
+}
+function buildProjectRunner(command, runtime, passThrough, options) {
+  if (command === 'build') {
+    switch (runtime) {
+      case 'bun':
+        return [{
+          command: 'bun',
+          args: ['build', './src/main.ts', '--outdir', './dist', '--target', 'bun', ...passThrough]
+        }];
+      case 'deno':
+        return [{
+          command: 'deno',
+          args: ['compile', '--allow-env', '--allow-net', '--output', join('dist', 'app'), 'src/main.ts', ...passThrough]
+        }];
+      case 'cloudflare-workers':
+        return [{
+          command: 'wrangler',
+          args: ['deploy', '--dry-run', ...passThrough]
+        }];
+      default:
+        return [{
+          command: 'vite',
+          args: ['build', ...passThrough],
+          mode: 'single-run'
+        }, {
+          command: 'tsc',
+          args: ['-p', 'tsconfig.build.json'],
+          mode: 'single-run'
+        }];
+    }
+  }
+  if (command === 'dev') {
+    if (options.devRunner === 'native') {
+      const nativeStep = buildNativeRuntimeDevStep(runtime, passThrough);
+      if (nativeStep) {
+        return [nativeStep];
+      }
+    }
+    switch (runtime) {
+      case 'bun':
+        return [buildFluoDevRunnerStep(runtime, passThrough)];
+      case 'deno':
+        return [buildFluoDevRunnerStep(runtime, passThrough)];
+      case 'cloudflare-workers':
+        return [buildFluoDevRunnerStep(runtime, passThrough)];
+      default:
+        if (options.rawWatch) {
+          return [buildNativeNodeWatchStep(passThrough)];
+        }
+        return [buildFluoDevRunnerStep(runtime, passThrough)];
+    }
+  }
+  switch (runtime) {
+    case 'bun':
+      return [{
+        command: 'bun',
+        args: ['dist/main.js', ...passThrough]
+      }];
+    case 'deno':
+      return [{
+        command: join('dist', 'app'),
+        args: [...passThrough]
+      }];
+    case 'cloudflare-workers':
+      return [{
+        command: 'wrangler',
+        args: ['dev', '--remote', '--show-interactive-dev-session=false', ...passThrough]
+      }];
+    default:
+      return [{
+        command: 'node',
+        args: ['dist/main.js', ...passThrough],
+        mode: 'single-run'
+      }];
+  }
+}
+async function runProjectRunnerSteps(steps, runtime, options) {
+  for (const step of steps) {
+    const exitCode = await runtime.spawnCommand(step.command, step.args, options);
+    if (exitCode !== 0) {
+      return exitCode;
+    }
+  }
+  return 0;
+}
+function withPipedAppColorTtyBootstrap(steps, env) {
+  if (env[PRETTY_TTY_COLOR_ENV] !== '1') {
+    return steps;
+  }
+  return steps.map(step => {
+    const preserveColorTtyImport = getPreserveColorTtyImport();
+    if (step.command === 'node' && step.mode !== 'fluo-restart') {
+      return {
+        ...step,
+        args: ['--import', preserveColorTtyImport, ...step.args]
+      };
+    }
+    if (step.command === 'bun' && (step.mode === 'runtime-native-watch' || step.args[0] === 'dist/main.js')) {
+      return {
+        ...step,
+        args: ['--preload', preserveColorTtyImport, ...step.args]
+      };
+    }
+    return step;
+  });
+}
+function parseScriptArgs(argv) {
+  let devRunner;
+  let dryRun = false;
+  let packageManager;
+  let rawWatch = false;
+  let reporter = 'auto';
+  let verbose = false;
+  const passThrough = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--dry-run') {
+      dryRun = true;
+      continue;
+    }
+    if (arg === '--verbose') {
+      verbose = true;
+      continue;
+    }
+    if (arg === '--raw-watch') {
+      rawWatch = true;
+      continue;
+    }
+    if (arg === '--runner') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('Expected --runner to have a value.');
+      }
+      if (!(value === 'fluo' || value === 'native')) {
+        throw new Error(`Invalid --runner value "${value}". Use one of: fluo, native.`);
+      }
+      devRunner = value;
+      index += 1;
+      continue;
+    }
+    if (arg === '--reporter') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('Expected --reporter to have a value.');
+      }
+      if (!(value === 'auto' || value === 'pretty' || value === 'stream' || value === 'silent')) {
+        throw new Error(`Invalid --reporter value "${value}". Use one of: auto, pretty, stream, silent.`);
+      }
+      reporter = value;
+      index += 1;
+      continue;
+    }
+    if (arg === '--package-manager') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('Expected --package-manager to have a value.');
+      }
+      if (!SUPPORTED_PACKAGE_MANAGERS.has(value)) {
+        throw new Error(`Invalid --package-manager value "${value}". Use one of: pnpm, npm, yarn, bun.`);
+      }
+      packageManager = value;
+      index += 1;
+      continue;
+    }
+    if (arg === '--') {
+      passThrough.push(...argv.slice(index + 1));
+      break;
+    }
+    passThrough.push(arg);
+  }
+  return {
+    devRunner,
+    dryRun,
+    packageManager,
+    passThrough,
+    rawWatch,
+    reporter,
+    verbose
+  };
+}
+function isEnabledEnvironmentFlag(value) {
+  return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}
+function resolveReporterMode(parsed, runtime) {
+  if (parsed.reporter !== 'auto') {
+    return parsed.reporter;
+  }
+  if (parsed.verbose || isEnabledEnvironmentFlag(runtime.env?.FLUO_VERBOSE)) {
+    return 'stream';
+  }
+  return 'app';
+}
+function resolveDevRunnerPreference(parsed, env, runtime) {
+  const configured = parsed.devRunner ?? env.FLUO_DEV_RUNNER;
+  if (configured === undefined || configured === '') {
+    return runtime === 'node' ? 'fluo' : 'native';
+  }
+  if (configured === 'fluo' || configured === 'native') {
+    return configured;
+  }
+  throw new Error(`Invalid FLUO_DEV_RUNNER value "${configured}". Use one of: fluo, native.`);
+}
+function renderStep(step) {
+  return `${step.command} ${step.args.join(' ')}`.trim();
+}
+function createBoundedBufferStream(limit) {
+  let buffer = '';
+  return {
+    flush(target) {
+      if (buffer.length > 0) {
+        target.write(buffer);
+      }
+    },
+    hasContent() {
+      return buffer.length > 0;
+    },
+    write(message) {
+      buffer += message;
+      if (buffer.length > limit) {
+        buffer = buffer.slice(buffer.length - limit);
+      }
+    }
+  };
+}
+function createLinePrefixedStream(target, prefix) {
+  let atLineStart = true;
+  return {
+    finalizeLine() {
+      if (!atLineStart) {
+        target.write('\n');
+        atLineStart = true;
+      }
+    },
+    write(message) {
+      for (const character of message) {
+        if (atLineStart && character !== '\n') {
+          target.write(prefix);
+          atLineStart = false;
+        }
+        target.write(character);
+        if (character === '\n') {
+          atLineStart = true;
+        }
+      }
+    }
+  };
+}
+function createReporterStreams(mode, verbose, stdout, stderr) {
+  if (mode === 'stream') {
+    return {
+      finalizeChildOutputBeforeStatus() {},
+      flushBufferedStdoutOnFailure() {},
+      stdio: 'inherit'
+    };
+  }
+  if (mode === 'app') {
+    return {
+      finalizeChildOutputBeforeStatus() {},
+      flushBufferedStdoutOnFailure() {},
+      stderr,
+      stdio: 'pipe',
+      stdout
+    };
+  }
+  if (mode === 'pretty') {
+    if (verbose) {
+      return {
+        finalizeChildOutputBeforeStatus() {},
+        flushBufferedStdoutOnFailure() {},
+        stderr,
+        stdio: 'pipe',
+        stdout
+      };
+    }
+    const prefixedStdout = createLinePrefixedStream(stdout, PRETTY_CHILD_OUTPUT_PREFIX);
+    const prefixedStderr = createLinePrefixedStream(stderr, PRETTY_CHILD_OUTPUT_PREFIX);
+    return {
+      finalizeChildOutputBeforeStatus() {
+        prefixedStdout.finalizeLine();
+        prefixedStderr.finalizeLine();
+      },
+      flushBufferedStdoutOnFailure() {},
+      stderr: prefixedStderr,
+      stdio: 'pipe',
+      stdout: prefixedStdout
+    };
+  }
+  if (mode === 'silent') {
+    if (verbose) {
+      return {
+        finalizeChildOutputBeforeStatus() {},
+        flushBufferedStdoutOnFailure() {},
+        stderr,
+        stdio: 'pipe',
+        stdout
+      };
+    }
+    const bufferedStdout = createBoundedBufferStream(FAILURE_STDOUT_BUFFER_LIMIT);
+    return {
+      finalizeChildOutputBeforeStatus() {},
+      flushBufferedStdoutOnFailure() {
+        if (bufferedStdout.hasContent()) {
+          stderr.write('[fluo] child stdout before failure:\n');
+          bufferedStdout.flush(stderr);
+          stderr.write('\n');
+        }
+      },
+      stderr,
+      stdio: 'pipe',
+      stdout: bufferedStdout
+    };
+  }
+  return {
+    finalizeChildOutputBeforeStatus() {},
+    flushBufferedStdoutOnFailure() {},
+    stdio: 'inherit'
+  };
+}
+
+/**
+ * Renders lifecycle command help text.
+ *
+ * @param command Lifecycle command whose help text should be rendered.
+ * @returns Human-readable lifecycle command usage text.
+ */
+export function scriptUsage(command) {
+  const nodeEnv = command === 'dev' ? 'development' : 'production';
+  return [`Usage: fluo ${command} [options] [-- <args>]`, '', `Run the generated fluo project ${command} lifecycle with NODE_ENV defaulting to ${nodeEnv} when unset.`, '', 'Default output forwards child stdout/stderr without fluo lifecycle UI.', 'Use --reporter pretty for fluo lifecycle status + app │ prefixes.', 'Use --verbose (or FLUO_VERBOSE=1) to expose raw runtime/tooling output.', '', 'Options', '  --dry-run                              Print the command without running it.', command === 'dev' ? '  --raw-watch                            Use the runtime-native Node watcher instead of the fluo restart runner.' : undefined, command === 'dev' ? '  --runner <fluo|native>                 Select fluo restart supervision or runtime-native watch (default: fluo for Node, native for non-Node runtimes).' : undefined, '  --reporter <auto|pretty|stream|silent> Choose lifecycle reporter output mode (default: auto).', '  --verbose                             Expose raw child process output; also honored by FLUO_VERBOSE=1.', `  --help                                 Show help for the ${command} command.`].filter(line => typeof line === 'string').join('\n');
+}
+
+/**
+ * Runs one generated-project lifecycle command through the CLI-owned runtime command matrix.
+ *
+ * @param command Lifecycle command to run.
+ * @param argv Command-specific arguments after the lifecycle command name.
+ * @param runtime Runtime dependencies used by tests, sandboxes, and embedders.
+ * @returns Process-style exit code from the lifecycle command.
+ */
+export async function runScriptCommand(command, argv, runtime = {}) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    (runtime.stdout ?? process.stdout).write(`${scriptUsage(command)}\n`);
+    return 0;
+  }
+  const env = runtime.env ?? EMPTY_ENV;
+  const stdout = runtime.stdout ?? process.stdout;
+  const stderr = runtime.stderr ?? process.stderr;
+  const project = findProjectManifest(runtime.cwd ?? process.cwd());
+  if (!project) {
+    throw new Error(`Unable to find package.json for fluo ${command}.`);
+  }
+  const parsed = parseScriptArgs(argv);
+  const projectRuntime = detectProjectRuntime(project.manifest);
+  const defaultNodeEnv = command === 'dev' ? 'development' : 'production';
+  const rawWatch = parsed.rawWatch || isEnabledEnvironmentFlag(env.FLUO_DEV_RAW_WATCH);
+  if (command !== 'dev' && parsed.devRunner) {
+    throw new Error('--runner is only supported for fluo dev. Use -- to forward --runner to the child command.');
+  }
+  const devRunner = command === 'dev' ? resolveDevRunnerPreference(parsed, env, projectRuntime) : 'fluo';
+  const runnerSteps = buildProjectRunner(command, projectRuntime, parsed.passThrough, {
+    devRunner,
+    rawWatch
+  });
+  const reporterMode = resolveReporterMode(parsed, {
+    ...runtime,
+    env,
+    stdout
+  });
+  const verbose = parsed.verbose || isEnabledEnvironmentFlag(env.FLUO_VERBOSE);
+  const childEnv = withPipedReporterColorEnv(withProjectLocalBin(withDefaultNodeEnv(env, defaultNodeEnv), project.directory), reporterMode, stdout, stderr);
+  const colorAwareRunnerSteps = withPipedAppColorTtyBootstrap(runnerSteps, childEnv);
+  if (command === 'dev' && (reporterMode === 'pretty' || verbose)) {
+    childEnv[SHOW_NODE_RESTART_NOTICE_ENV] = '1';
+  }
+  if (parsed.dryRun) {
+    for (const step of colorAwareRunnerSteps) {
+      stdout.write(`Would run: ${step.command} ${step.args.join(' ')}\n`);
+    }
+    stdout.write(`Project: ${project.path}\n`);
+    stdout.write(`Runtime: ${projectRuntime}\n`);
+    stdout.write(`NODE_ENV: ${childEnv.NODE_ENV ?? ''}\n`);
+    stdout.write(`Reporter: ${reporterMode}\n`);
+    if (command === 'dev') {
+      stdout.write(`Watch mode: ${colorAwareRunnerSteps.map(step => step.mode ?? 'single-run').join(', ')}\n`);
+    }
+    return 0;
+  }
+  if (reporterMode === 'pretty') {
+    stdout.write(`[fluo] ${command} ${projectRuntime} lifecycle starting\n`);
+    stdout.write(`[fluo] ${colorAwareRunnerSteps.map(renderStep).join(' && ')}\n`);
+  }
+  const reporterStreams = createReporterStreams(reporterMode, verbose, stdout, stderr);
+  const exitCode = await runProjectRunnerSteps(colorAwareRunnerSteps, {
+    spawnCommand: runtime.spawnCommand ?? defaultSpawnCommand
+  }, {
+    cwd: project.directory,
+    env: childEnv,
+    ...reporterStreams
+  });
+  if (reporterMode === 'pretty') {
+    reporterStreams.finalizeChildOutputBeforeStatus();
+    if (exitCode === 0) {
+      stdout.write(`[fluo] ${command} lifecycle completed\n`);
+    } else {
+      reporterStreams.flushBufferedStdoutOnFailure();
+      stderr.write(`[fluo] ${command} lifecycle failed with exit code ${exitCode}\n`);
+    }
+  } else if (reporterMode === 'silent' && exitCode !== 0) {
+    reporterStreams.flushBufferedStdoutOnFailure();
+    stderr.write(`[fluo] ${command} lifecycle failed with exit code ${exitCode}\n`);
+  }
+  return exitCode;
+}

package/dist/dev-runner/node-restart-runner.d.ts

@@ -0,0 +1,55 @@
+import { type ChildProcess } from 'node:child_process';
+import { type FSWatcher } from 'node:fs';
+type RestartRunnerStream = {
+    isTTY?: boolean;
+    write(message: string): unknown;
+};
+type RestartChildSpawner = (command: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: 'inherit';
+}) => ChildProcess;
+/** Runtime target handled by the fluo-owned development restart runner. */
+export type DevRunnerRuntime = 'bun' | 'cloudflare-workers' | 'deno' | 'node';
+type RestartSignal = 'SIGINT' | 'SIGTERM';
+type RestartSignalTarget = {
+    off(signal: RestartSignal, listener: () => void): unknown;
+    once(signal: RestartSignal, listener: () => void): unknown;
+};
+type RestartWatcherFactory = (target: string, optionsOrListener: {
+    recursive: boolean;
+} | ((event: string, filename: string | Buffer | null) => void), listener?: (event: string, filename: string | Buffer | null) => void) => FSWatcher;
+type ContentChangeGate = {
+    commitBaseline(paths: Iterable<string>): void;
+    hasMeaningfulChange(paths: Iterable<string>): boolean;
+};
+/** Options used to configure the fluo-owned Node restart-on-watch process boundary. */
+export type NodeRestartRunnerOptions = {
+    appArgs?: string[];
+    debounceMs?: number;
+    env: NodeJS.ProcessEnv;
+    projectDirectory?: string;
+    runtime?: DevRunnerRuntime;
+    signalTarget?: RestartSignalTarget;
+    spawnChild?: RestartChildSpawner;
+    stderr?: RestartRunnerStream;
+    stdout?: RestartRunnerStream;
+    watchTarget?: RestartWatcherFactory;
+};
+/**
+ * Creates a content-diff gate for fluo-owned dev restarts.
+ *
+ * @param projectDirectory Project root used for ignore matching.
+ * @param ignorePatterns Additional or default ignore patterns to apply before hashing.
+ * @returns A gate that reports whether watched paths changed by content rather than by filesystem event alone.
+ */
+export declare function createContentChangeGate(projectDirectory: string, ignorePatterns?: string[]): ContentChangeGate;
+/**
+ * Runs the Node.js development lifecycle through fluo-owned restart supervision.
+ *
+ * @param options Runner dependencies and project settings.
+ * @returns A promise that resolves with the final child exit code when the runner stops.
+ */
+export declare function runNodeRestartRunner(options: NodeRestartRunnerOptions): Promise<number>;
+export {};
+//# sourceMappingURL=node-restart-runner.d.ts.map

package/dist/dev-runner/node-restart-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-restart-runner.d.ts","sourceRoot":"","sources":["../../src/dev-runner/node-restart-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAA0D,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAIjG,KAAK,mBAAmB,GAAG;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEF,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,KAAK,YAAY,CAAC;AACjJ,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,oBAAoB,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9E,KAAK,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1C,KAAK,mBAAmB,GAAG;IACzB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;IAC1D,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;CAC5D,CAAC;AAEF,KAAK,qBAAqB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,KAAK,SAAS,CAAC;AAE1O,KAAK,iBAAiB,GAAG;IACvB,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC9C,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;CACvD,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,CAAC;AAgGF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,EAAoB,GAAG,iBAAiB,CAuB/H;AAqED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2J7F"}