transone-cli 0.1.0

package/dist/index-30n2h2ep.js

@@ -0,0 +1,1429 @@
+// @bun
+import {
+  __require
+} from "./index-yb2wsc7f.js";
+
+// src/target/types.ts
+var TARGET_TYPES = [
+  "web",
+  "mp-weixin",
+  "mp-alipay",
+  "mp-bytedance",
+  "app-ios",
+  "app-android",
+  "app-harmony"
+];
+function isTargetType(value) {
+  return typeof value === "string" && TARGET_TYPES.includes(value);
+}
+
+// src/config.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var DEFAULT_CONFIG = {
+  entry: "src/main.ts",
+  server: {
+    host: "127.0.0.1",
+    port: 52211,
+    proxy: {}
+  },
+  build: {
+    outDir: "dist/build/h5",
+    basePath: "",
+    directoryPages: false
+  }
+};
+function defineConfig(config) {
+  return config;
+}
+async function resolveConfig(options = {}) {
+  const root = resolve(options.root ?? process.cwd());
+  const configFile = resolve(root, "transone.config.ts");
+  const hasInlineConfig = options.config !== undefined;
+  const loadedConfig = hasInlineConfig ? { exists: false } : await loadConfigFile(configFile);
+  let fileConfig = {};
+  if (loadedConfig.exists) {
+    const config2 = loadedConfig.config;
+    validateUserConfig(config2);
+    fileConfig = config2;
+  }
+  if (hasInlineConfig) {
+    validateUserConfig(options.config);
+  }
+  const inlineOverrides = toInlineOverrides(options);
+  validateUserConfig(inlineOverrides);
+  const config = mergeConfig(fileConfig, options.config ?? {}, inlineOverrides);
+  const entry = resolve(root, config.entry);
+  if (!existsSync(entry) && !config.library) {
+    throw new Error(`Entry file does not exist: ${entry}`);
+  }
+  const pages = await resolvePages(root, entry, config.pages);
+  const target = resolveTarget(options.target);
+  return {
+    root,
+    ...loadedConfig.exists ? { configFile } : {},
+    entry,
+    pages,
+    target,
+    server: {
+      host: config.server.host,
+      port: config.server.port,
+      proxy: config.server.proxy
+    },
+    build: {
+      outDir: resolve(root, config.build.outDir),
+      basePath: normalizeBasePath(config.build.basePath),
+      directoryPages: config.build.directoryPages
+    },
+    ...config.library ? { library: resolveLibrary(root, config.library) } : {}
+  };
+}
+function resolveLibrary(root, library) {
+  return {
+    entry: resolve(root, library.entry ?? "src/index.ts"),
+    outDir: resolve(root, library.outDir ?? "dist"),
+    external: library.external ?? [],
+    tsconfigs: (library.tsconfigs ?? ["tsconfig.build.json"]).map((path) => resolve(root, path)),
+    dts: library.dts ?? true,
+    splitting: library.splitting ?? true,
+    sourcemap: library.sourcemap ?? true,
+    minify: library.minify
+  };
+}
+function normalizeBasePath(base) {
+  const trimmed = (base ?? "").trim();
+  if (!trimmed || trimmed === "/") {
+    return "";
+  }
+  const withLeading = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
+}
+function resolveTarget(target) {
+  if (target === undefined) {
+    return "web";
+  }
+  if (isTargetType(target)) {
+    return target;
+  }
+  throw new Error(`Unknown build target "${String(target)}". ` + "Available targets: web, mp-weixin, mp-alipay, mp-bytedance, " + "app-ios, app-android, app-harmony.");
+}
+async function resolvePages(root, entry, pages) {
+  const resolved = { "/": entry };
+  for (const [route, pageEntry] of Object.entries(pages ?? {})) {
+    const normalized = normalizePageRoute(route);
+    const absolute = resolve(root, pageEntry);
+    if (!existsSync(absolute)) {
+      throw new Error(`Page entry file does not exist for "${normalized}": ${absolute}`);
+    }
+    resolved[normalized] = absolute;
+  }
+  return resolved;
+}
+function normalizePageRoute(route) {
+  if (route === "/") {
+    throw new Error('Config pages must not redefine the root page "/"; use config.entry instead');
+  }
+  const normalized = route.replace(/\/+$/, "");
+  if (normalized === "") {
+    throw new Error(`Page route must not be empty: ${route}`);
+  }
+  return normalized;
+}
+var configLoadSequence = 0;
+async function loadConfigFile(configFile) {
+  if (!existsSync(configFile)) {
+    return { exists: false };
+  }
+  configLoadSequence += 1;
+  const module = await import(`${configFile}?transone_config=${configLoadSequence}`);
+  return { exists: true, config: module.default };
+}
+function toInlineOverrides(options) {
+  const server = {};
+  const build = {};
+  if (options.host !== undefined) {
+    server.host = options.host;
+  }
+  if (options.port !== undefined) {
+    server.port = options.port;
+  }
+  if (options.outDir !== undefined) {
+    build.outDir = options.outDir;
+  }
+  if (options.base !== undefined) {
+    build.basePath = options.base;
+  }
+  return {
+    ...Object.keys(server).length > 0 ? { server } : {},
+    ...Object.keys(build).length > 0 ? { build } : {}
+  };
+}
+function mergeConfig(...configs) {
+  return configs.reduce((merged, config) => {
+    const server = config.server;
+    const build = config.build;
+    return {
+      entry: config.entry ?? merged.entry,
+      pages: config.pages ?? merged.pages,
+      server: {
+        host: server?.host ?? merged.server.host,
+        port: server?.port ?? merged.server.port,
+        proxy: {
+          ...merged.server.proxy,
+          ...server?.proxy
+        }
+      },
+      build: {
+        outDir: build?.outDir ?? merged.build.outDir,
+        basePath: build?.basePath ?? merged.build.basePath,
+        directoryPages: build?.directoryPages ?? merged.build.directoryPages
+      },
+      library: config.library ?? merged.library
+    };
+  }, DEFAULT_CONFIG);
+}
+function validateUserConfig(config) {
+  assertRecord(config, "Config");
+  if (config.entry !== undefined && typeof config.entry !== "string") {
+    throw new Error("Config entry must be a string");
+  }
+  if (config.pages !== undefined) {
+    validatePagesConfig(config.pages);
+  }
+  if (config.server !== undefined) {
+    validateServerConfig(config.server);
+  }
+  if (config.build !== undefined) {
+    validateBuildConfig(config.build);
+  }
+  if (config.library !== undefined) {
+    validateLibraryConfig(config.library);
+  }
+}
+function validateLibraryConfig(library) {
+  assertRecord(library, "Config library");
+  if (library.entry !== undefined && typeof library.entry !== "string") {
+    throw new Error("Config library.entry must be a string");
+  }
+  if (library.outDir !== undefined && typeof library.outDir !== "string") {
+    throw new Error("Config library.outDir must be a string");
+  }
+  if (library.external !== undefined) {
+    assertStringArray(library.external, "Config library.external");
+  }
+  if (library.tsconfigs !== undefined) {
+    assertStringArray(library.tsconfigs, "Config library.tsconfigs");
+  }
+  for (const key of ["dts", "splitting", "sourcemap", "minify"]) {
+    if (library[key] !== undefined && typeof library[key] !== "boolean") {
+      throw new Error(`Config library.${key} must be a boolean`);
+    }
+  }
+}
+function assertStringArray(value, name) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${name} must be an array of strings`);
+  }
+}
+function validatePagesConfig(pages, label = "Config pages") {
+  assertRecord(pages, label);
+  for (const [route, entry] of Object.entries(pages)) {
+    if (!route.startsWith("/")) {
+      throw new Error(`Page route must start with "/": ${route}`);
+    }
+    if (typeof entry !== "string") {
+      throw new Error(`Page entry for "${route}" must be a string`);
+    }
+  }
+}
+function validateServerConfig(server) {
+  assertRecord(server, "Config server");
+  if (server.host !== undefined && typeof server.host !== "string") {
+    throw new Error("Config server.host must be a string");
+  }
+  const port = server.port;
+  if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new Error("Config server.port must be an integer between 0 and 65535");
+  }
+  if (server.proxy === undefined) {
+    return;
+  }
+  assertRecord(server.proxy, "Config server.proxy");
+  for (const [prefix, value] of Object.entries(server.proxy)) {
+    if (!prefix.startsWith("/")) {
+      throw new Error(`Proxy prefix must start with "/": ${prefix}`);
+    }
+    const target = getProxyTarget(value);
+    validateProxyTarget(target);
+  }
+}
+function validateBuildConfig(build) {
+  assertRecord(build, "Config build");
+  if (build.outDir !== undefined && typeof build.outDir !== "string") {
+    throw new Error("Config build.outDir must be a string");
+  }
+  if (build.basePath !== undefined && typeof build.basePath !== "string") {
+    throw new Error("Config build.basePath must be a string");
+  }
+  if (build.directoryPages !== undefined && typeof build.directoryPages !== "boolean") {
+    throw new Error("Config build.directoryPages must be a boolean");
+  }
+}
+function getProxyTarget(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  assertRecord(value, "Proxy options");
+  if (typeof value.target !== "string") {
+    throw new Error("Proxy target must be a string");
+  }
+  if (value.changeOrigin !== undefined && typeof value.changeOrigin !== "boolean") {
+    throw new Error("Proxy changeOrigin must be a boolean");
+  }
+  if (value.rewrite !== undefined && typeof value.rewrite !== "function") {
+    throw new Error("Proxy rewrite must be a function");
+  }
+  return value.target;
+}
+function validateProxyTarget(target) {
+  try {
+    const url = new URL(target);
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      return;
+    }
+  } catch {}
+  throw new Error(`Proxy target must use http or https: ${target}`);
+}
+function assertRecord(value, name) {
+  if (!isRecord(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+
+// src/target/web-target.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+
+// src/build-output.ts
+function isEntryJavaScriptOutput(output) {
+  return output.kind === "entry-point" && isJavaScriptPath(output.path);
+}
+function isStylesheetOutput(output) {
+  return /\.css$/i.test(output.path);
+}
+function isJavaScriptPath(path) {
+  return /\.(?:[cm]?js)$/i.test(path);
+}
+
+// src/safe-path.ts
+import { lstat, realpath } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve as resolve2, sep } from "path";
+async function assertSafeSubdirectory(root, path, errorMessage) {
+  try {
+    const canonicalRoot = await realpath(root);
+    const canonicalPath = await canonicalizePotentialPath(path);
+    if (!isStrictSubdirectory(canonicalRoot, canonicalPath)) {
+      throw new Error(errorMessage);
+    }
+  } catch {
+    throw new Error(errorMessage);
+  }
+}
+async function assertSafeSubdirectoryDoesNotContain(root, path, protectedPath, errorMessage) {
+  try {
+    const lexicalPath = resolve2(path);
+    const lexicalProtectedPath = resolve2(protectedPath);
+    const canonicalRoot = await realpath(root);
+    const canonicalPath = await canonicalizePotentialPath(path);
+    const canonicalProtectedPath = await realpath(protectedPath);
+    if (!isStrictSubdirectory(canonicalRoot, canonicalPath) || isPathWithinOrEqual(lexicalPath, lexicalProtectedPath) || isPathWithinOrEqual(canonicalPath, canonicalProtectedPath)) {
+      throw new Error(errorMessage);
+    }
+  } catch {
+    throw new Error(errorMessage);
+  }
+}
+async function canonicalizePotentialPath(path) {
+  const ancestor = await findExistingAncestor(path);
+  const canonicalAncestor = await realpath(ancestor);
+  return resolve2(canonicalAncestor, relative(ancestor, path));
+}
+async function findExistingAncestor(path) {
+  let candidate = path;
+  while (candidate !== dirname(candidate)) {
+    try {
+      await lstat(candidate);
+      return candidate;
+    } catch (error) {
+      if (!isMissingPathError(error)) {
+        throw error;
+      }
+    }
+    candidate = dirname(candidate);
+  }
+  await lstat(candidate);
+  return candidate;
+}
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isStrictSubdirectory(root, path) {
+  const pathFromRoot = relative(root, path);
+  return pathFromRoot !== "" && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`) && !isAbsolute(pathFromRoot);
+}
+function isPathWithinOrEqual(parent, candidate) {
+  const pathFromParent = relative(parent, candidate);
+  return pathFromParent === "" || pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep}`) && !isAbsolute(pathFromParent);
+}
+
+// src/target/web-target.ts
+var INVALID_OUTPUT_DIRECTORY_MESSAGE = "Build output must be a subdirectory of the project root";
+
+class WebTarget {
+  type = "web";
+  label = "\u9759\u6001\u7AD9\u70B9 / SPA\uFF08\u590D\u7528 TSone \u7B56\u7565\u5316\u6E32\u67D3\uFF09";
+  async build(config, _options) {
+    const entries = [...new Set(Object.values(config.pages))];
+    for (const entry of entries) {
+      await assertSafeSubdirectoryDoesNotContain(config.root, config.build.outDir, entry, INVALID_OUTPUT_DIRECTORY_MESSAGE);
+    }
+    const { renderProjectHtml } = await import("./project-ybacfze8.js");
+    for (const [route, entry] of Object.entries(config.pages)) {
+      await renderProjectHtml(config, {}, entry, route);
+    }
+    await rm(config.build.outDir, { recursive: true, force: true });
+    await mkdir(config.build.outDir, { recursive: true });
+    const builtByEntry = new Map;
+    const failures = [];
+    for (const entry of entries) {
+      const built = await buildPage(config, entry);
+      if (typeof built === "string") {
+        failures.push(built);
+        continue;
+      }
+      builtByEntry.set(entry, built);
+    }
+    if (failures.length > 0) {
+      throw buildFailure(failures);
+    }
+    const assetsBuilt = [];
+    for (const [route, entry] of Object.entries(config.pages)) {
+      const page = builtByEntry.get(entry);
+      if (!page) {
+        throw new Error(`Missing built assets for entry: ${entry}`);
+      }
+      const pageHtmlPath = htmlPath(config, route);
+      const html = await renderProjectHtml(config, {
+        head: page.stylesheetAssets.map((asset) => ({
+          tag: "link",
+          attributes: {
+            rel: "stylesheet",
+            href: toAssetUrl(config.build.outDir, pageHtmlPath, asset)
+          }
+        })),
+        scripts: page.javascriptAssets.map((asset) => ({
+          type: "module",
+          src: toAssetUrl(config.build.outDir, pageHtmlPath, asset)
+        }))
+      }, page.entry, route);
+      await mkdir(dirname2(pageHtmlPath), { recursive: true });
+      await writeFile(pageHtmlPath, html);
+      assetsBuilt.push(...page.assets, pageHtmlPath);
+    }
+    return {
+      root: config.root,
+      outDir: config.build.outDir,
+      assetsBuilt
+    };
+  }
+}
+async function buildPage(config, entry) {
+  let result;
+  try {
+    result = await Bun.build({
+      entrypoints: [entry],
+      outdir: config.build.outDir,
+      target: "browser",
+      format: "esm",
+      minify: process.env.TRANSONE_MINIFY !== "0",
+      naming: { entry: "[name].[ext]", chunk: "[name]-[hash].[ext]" },
+      throw: false
+    });
+  } catch (error) {
+    return pageFailureReason(entry, [errorMessage(error)]);
+  }
+  const assets = result.outputs.map((output) => resolve3(output.path));
+  const javascriptAssets = result.outputs.filter(isEntryJavaScriptOutput).map((output) => resolve3(output.path));
+  const stylesheetAssets = result.outputs.filter(isStylesheetOutput).map((output) => resolve3(output.path));
+  if (!result.success || assets.length === 0 || javascriptAssets.length === 0) {
+    return pageFailureReason(entry, result.logs.map((log) => log.message), {
+      success: result.success,
+      hasOutput: assets.length > 0,
+      hasJavaScript: javascriptAssets.length > 0
+    });
+  }
+  return {
+    entry,
+    assets,
+    javascriptAssets,
+    stylesheetAssets
+  };
+}
+function pageFailureReason(entry, logs, state) {
+  const reasons = [
+    state && !state.success ? "Bun build reported failure" : "",
+    state && !state.hasOutput ? "Bun emitted no output files" : "",
+    state && !state.hasJavaScript ? "Bun emitted no JavaScript output" : "",
+    ...logs
+  ].filter((reason) => reason !== "");
+  return `${entry}: ${reasons.join(`
+`)}`;
+}
+function buildFailure(failures) {
+  if (failures.length === 1) {
+    return new Error(`Failed to build TransOne application: ${failures[0]}`);
+  }
+  return new Error(`Failed to build TransOne application:
+${failures.map((failure) => `- ${failure}`).join(`
+`)}`);
+}
+function htmlPath(config, route) {
+  if (route === "/") {
+    return resolve3(config.build.outDir, "index.html");
+  }
+  const relativeRoute = route.replace(/^\/+/, "");
+  if (config.build.directoryPages) {
+    return resolve3(config.build.outDir, relativeRoute, "index.html");
+  }
+  return resolve3(config.build.outDir, `${relativeRoute}.html`);
+}
+function toAssetUrl(outDir, fromHtmlFile, asset) {
+  const fromOutDir = relative2(outDir, asset).split(sep2).join("/");
+  if (fromOutDir === "" || fromOutDir === ".." || fromOutDir.startsWith("../") || isAbsolute2(fromOutDir)) {
+    throw new Error(`Build asset must be inside the output directory: ${asset}`);
+  }
+  const fromHtmlDir = dirname2(fromHtmlFile);
+  const assetPath = relative2(fromHtmlDir, asset).split(sep2).join("/");
+  return `./${assetPath}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/target/placeholder-target.ts
+class PlaceholderTarget {
+  type;
+  label;
+  plannedMilestone;
+  constructor(type, label, plannedMilestone) {
+    this.type = type;
+    this.label = label;
+    this.plannedMilestone = plannedMilestone;
+  }
+  async build(_config, _options) {
+    const available = ["web"].map((target) => `'${target}'`).join(", ");
+    throw new Error(`Target "${this.type}" (${this.label}) \u5C1A\u672A\u5B9E\u73B0\uFF0C\u9884\u8BA1\u5728 ${this.plannedMilestone} \u843D\u5730\u3002` + `\u5F53\u524D\u53EF\u7528\u76EE\u6807\u7AEF\uFF1A${available}\u3002`);
+  }
+}
+
+// src/target/registry.ts
+class TargetRegistry {
+  targets = new Map;
+  constructor() {
+    this.register(new WebTarget);
+    this.register(new PlaceholderTarget("mp-weixin", "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B", "M2"));
+    this.register(new PlaceholderTarget("mp-alipay", "\u963F\u91CC\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B", "M3"));
+    this.register(new PlaceholderTarget("mp-bytedance", "\u5B57\u8282\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B", "M3"));
+    this.register(new PlaceholderTarget("app-ios", "iOS \u539F\u751F App", "\u8FDC\u671F"));
+    this.register(new PlaceholderTarget("app-android", "Android \u539F\u751F App", "\u8FDC\u671F"));
+    this.register(new PlaceholderTarget("app-harmony", "\u9E3F\u8499\u539F\u751F App\uFF08ArkUI\uFF09", "\u8FDC\u671F"));
+  }
+  register(target) {
+    this.targets.set(target.type, target);
+  }
+  resolve(type) {
+    const target = this.targets.get(type);
+    if (!target) {
+      throw new Error(`Unknown build target: ${type}`);
+    }
+    return target;
+  }
+  getAvailableTargets() {
+    return [...this.targets.values()];
+  }
+}
+var targetRegistry = new TargetRegistry;
+
+// src/build.ts
+import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+async function build(options = {}) {
+  const config = await resolveConfig(options);
+  if (options.library) {
+    return buildLibrary(config);
+  }
+  const target = targetRegistry.resolve(config.target);
+  return target.build(config, options);
+}
+async function buildLibrary(config) {
+  const library = config.library;
+  if (!library) {
+    throw new Error("TransOne library build requires config.library");
+  }
+  await rm2(library.outDir, { recursive: true, force: true });
+  await mkdir2(library.outDir, { recursive: true });
+  if (library.dts) {
+    for (const tsconfig of library.tsconfigs) {
+      await runTsc(config.root, tsconfig);
+    }
+  }
+  const minify = library.minify ?? process.env.TRANSONE_MINIFY !== "0";
+  const result = await Bun.build({
+    entrypoints: [library.entry],
+    outdir: library.outDir,
+    root: dirname3(library.entry),
+    target: "browser",
+    format: "esm",
+    sourcemap: library.sourcemap ? "linked" : undefined,
+    splitting: library.splitting,
+    minify,
+    external: library.external,
+    throw: false
+  });
+  if (!result.success || result.outputs.length === 0) {
+    throw new Error(`Failed to build TransOne library:
+${result.logs.map((log) => log.message).join(`
+`)}`);
+  }
+  const assetsBuilt = result.outputs.map((output) => resolve4(output.path));
+  return { root: config.root, outDir: library.outDir, assetsBuilt };
+}
+async function runTsc(root, tsconfig) {
+  const proc = Bun.spawn(["bunx", "tsc", "--project", tsconfig], {
+    cwd: root,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(`tsc --project ${tsconfig} failed with exit code ${exitCode}`);
+  }
+}
+
+// src/create.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+var TRANSONE_FRAMEWORK_VERSION = "0.1.0";
+var TRANSONE_CLI_VERSION = "0.1.0";
+var GITHUB_URL = "https://github.com/geektech-team/transone";
+function createProject(options = {}) {
+  const root = options.root ?? process.cwd();
+  const name = options.name ?? basename(root);
+  const files = scaffoldFiles(name);
+  const existing = files.filter((file) => existsSync2(join(root, file.path)));
+  if (existing.length > 0) {
+    throw new Error(`Refusing to overwrite existing TransOne project files: ${existing.map((file) => file.path).join(", ")}`);
+  }
+  mkdirSync(join(root, "src"), { recursive: true });
+  const created = [];
+  for (const file of files) {
+    writeFileSync(join(root, file.path), file.content, "utf8");
+    created.push(file.path);
+  }
+  return { root, files: created };
+}
+function scaffoldFiles(name) {
+  return [
+    {
+      path: "package.json",
+      content: `${JSON.stringify({
+        name,
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "transone dev",
+          build: "transone build",
+          typecheck: "bunx tsc --noEmit"
+        },
+        dependencies: {
+          "@geektech/transone": `^${TRANSONE_FRAMEWORK_VERSION}`
+        },
+        devDependencies: {
+          "@geektech/transone-cli": `^${TRANSONE_CLI_VERSION}`
+        }
+      }, null, 2)}
+`
+    },
+    {
+      path: "transone.config.ts",
+      content: `import { defineConfig } from '@geektech/transone-cli';
+
+export default defineConfig({
+  entry: 'src/main.ts',
+});
+`
+    },
+    {
+      path: "tsconfig.json",
+      content: `${JSON.stringify({
+        compilerOptions: {
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          lib: ["ESNext", "DOM", "DOM.Iterable"],
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true,
+          verbatimModuleSyntax: true
+        },
+        include: ["src/**/*", "transone.config.ts"]
+      }, null, 2)}
+`
+    },
+    {
+      path: ".gitignore",
+      content: `node_modules/
+dist/
+`
+    },
+    {
+      path: "src/main.ts",
+      content: `import { Component, createApp, h, type VNode } from '@geektech/transone';
+
+class App extends Component<object, object> {
+  protected initState(): object {
+    return {};
+  }
+
+  protected initStyles(): void {
+    this.styleManager.addStyle('app-body', {
+      selector: 'body',
+      properties: {
+        margin: 0,
+        background: '#f7fbf6',
+        color: '#142216',
+        fontFamily:
+          "ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif",
+      },
+    });
+    this.styleManager.addStyle('app-shell', {
+      selector: '.app-shell',
+      properties: {
+        alignItems: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '14px',
+        justifyContent: 'center',
+        minHeight: '100vh',
+      },
+    });
+    this.styleManager.addStyle('app-title', {
+      selector: '.app-title',
+      properties: {
+        fontSize: '64px',
+        letterSpacing: 0,
+        lineHeight: 1.05,
+        margin: 0,
+      },
+    });
+    this.styleManager.addStyle('app-link', {
+      selector: '.app-link',
+      properties: {
+        color: '#2f7c39',
+        fontSize: '16px',
+        textDecoration: 'none',
+      },
+      hover: {
+        textDecoration: 'underline',
+      },
+    });
+  }
+
+  protected render(): VNode {
+    return h('main', { className: 'app-shell' }, [
+      h('h1', { className: 'app-title' }, ['TransOne']),
+      h(
+        'a',
+        { className: 'app-link', href: '${GITHUB_URL}' },
+        ['GitHub']
+      ),
+    ]);
+  }
+}
+
+export const app = createApp({
+  root: App,
+  document: {
+    lang: 'zh-CN',
+    title: 'TransOne',
+    description: '\u8F7B\u91CF\u7EA7\u7EAF TypeScript \u524D\u7AEF\u6846\u67B6',
+  },
+});
+
+app.mount();
+`
+    }
+  ];
+}
+
+// src/server.ts
+import { randomUUID } from "crypto";
+import {
+  basename as basename2,
+  extname,
+  isAbsolute as isAbsolute4,
+  relative as relative4,
+  resolve as resolve5,
+  sep as sep3
+} from "path";
+
+// src/proxy.ts
+var HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function createProxyHandler(proxy) {
+  const rules = Object.entries(proxy ?? {}).map(([prefix, options]) => toProxyRule(prefix, options)).sort((first, second) => second.prefix.length - first.prefix.length);
+  return async (request) => {
+    const sourceUrl = new URL(request.url);
+    const rule = rules.find(({ prefix }) => sourceUrl.pathname.startsWith(prefix));
+    if (!rule) {
+      return;
+    }
+    const target = createTargetUrl(rule, sourceUrl);
+    const headers = createRequestHeaders(request, sourceUrl, rule, target);
+    const body = request.method === "GET" || request.method === "HEAD" ? undefined : request.body;
+    try {
+      const upstream = await fetch(target, {
+        method: request.method,
+        headers,
+        body,
+        signal: request.signal,
+        redirect: "manual"
+      });
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: filterHeaders(upstream.headers)
+      });
+    } catch {
+      return new Response("Bad Gateway", { status: 502 });
+    }
+  };
+}
+function toProxyRule(prefix, value) {
+  const options = typeof value === "string" ? { target: value } : value;
+  return {
+    prefix,
+    target: new URL(options.target),
+    changeOrigin: options.changeOrigin ?? false,
+    ...options.rewrite === undefined ? {} : { rewrite: options.rewrite }
+  };
+}
+function createTargetUrl(rule, sourceUrl) {
+  const target = new URL(rule.target);
+  const pathname = rule.rewrite?.(sourceUrl.pathname) ?? sourceUrl.pathname;
+  target.pathname = joinPathnames(target.pathname, pathname);
+  target.search = sourceUrl.search;
+  return target;
+}
+function joinPathnames(basePathname, pathname) {
+  const base = basePathname === "/" ? "" : basePathname.replace(/\/+$/, "");
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${base}${path}` || "/";
+}
+function createRequestHeaders(request, sourceUrl, rule, target) {
+  const headers = filterHeaders(request.headers);
+  const incomingHost = request.headers.get("host") ?? sourceUrl.host;
+  headers.set("host", rule.changeOrigin ? target.host : incomingHost);
+  return headers;
+}
+function filterHeaders(source) {
+  const headers = new Headers(source);
+  const connection = headers.get("connection");
+  if (connection) {
+    connection.split(",").forEach((header) => {
+      const name = header.trim();
+      if (name) {
+        headers.delete(name);
+      }
+    });
+  }
+  HOP_BY_HOP_HEADERS.forEach((header) => headers.delete(header));
+  return headers;
+}
+
+// src/watch.ts
+import { watch } from "fs";
+import { readdir, stat } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join2, relative as relative3 } from "path";
+var RECURSIVE_WATCH_UNSUPPORTED_ERROR = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+var DEFAULT_DEBOUNCE_MS = 100;
+var DEFAULT_POLL_INTERVAL_MS = 300;
+function createFileWatcher(options) {
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  let timer;
+  const disposers = [];
+  const scheduleChange = (relativePath) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = undefined;
+      options.onChange(relativePath);
+    }, debounceMs);
+  };
+  disposers.push(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+  const nativeWatcher = tryCreateNativeWatcher(options.root, options.isRelevant, scheduleChange);
+  if (nativeWatcher) {
+    disposers.push(nativeWatcher);
+  } else {
+    disposers.push(createPollingWatcher(options.root, options.isRelevant, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, scheduleChange));
+  }
+  return {
+    dispose: () => {
+      disposers.splice(0).reverse().forEach((dispose) => dispose());
+    }
+  };
+}
+function tryCreateNativeWatcher(root, isRelevant, onRelevantChange) {
+  let watcher;
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => {
+      if (typeof filename !== "string") {
+        return;
+      }
+      const relativePath = toRelativePath(root, filename);
+      if (relativePath === undefined || !isRelevant(relativePath)) {
+        return;
+      }
+      onRelevantChange(relativePath);
+    });
+  } catch (error) {
+    if (isRecursiveWatchUnsupported(error)) {
+      return;
+    }
+    throw error;
+  }
+  return () => watcher.close();
+}
+function createPollingWatcher(root, isRelevant, intervalMs, onRelevantChange) {
+  let running = true;
+  let snapshot = new Map;
+  let timer;
+  const scan = async () => {
+    if (!running) {
+      return;
+    }
+    const next = new Map;
+    try {
+      await collectRelevantFiles(root, isRelevant, next);
+    } catch {
+      return;
+    }
+    let changedPath;
+    for (const [relativePath, snapshotEntry] of next) {
+      const previous = snapshot.get(relativePath);
+      if (!previous || previous.mtimeMs !== snapshotEntry.mtimeMs || previous.size !== snapshotEntry.size) {
+        changedPath = relativePath;
+        break;
+      }
+    }
+    if (changedPath === undefined) {
+      for (const relativePath of snapshot.keys()) {
+        if (!next.has(relativePath)) {
+          changedPath = relativePath;
+          break;
+        }
+      }
+    }
+    snapshot = next;
+    if (changedPath !== undefined) {
+      onRelevantChange(changedPath);
+    }
+  };
+  scan();
+  timer = setInterval(() => {
+    scan();
+  }, intervalMs);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return () => {
+    running = false;
+    if (timer) {
+      clearInterval(timer);
+    }
+  };
+}
+async function collectRelevantFiles(root, isRelevant, output) {
+  const pendingDirectories = [""];
+  while (pendingDirectories.length > 0) {
+    const relativeDirectory = pendingDirectories.pop();
+    if (relativeDirectory === undefined) {
+      break;
+    }
+    const absoluteDirectory = join2(root, relativeDirectory);
+    let entries;
+    try {
+      entries = await readdir(absoluteDirectory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const relativePath = relativeDirectory === "" ? entry.name : `${relativeDirectory}/${entry.name}`;
+      if (entry.isDirectory()) {
+        pendingDirectories.push(relativePath);
+        continue;
+      }
+      if (!entry.isFile() || !isRelevant(relativePath)) {
+        continue;
+      }
+      try {
+        const info = await stat(join2(root, relativePath));
+        output.set(relativePath, { mtimeMs: info.mtimeMs, size: info.size });
+      } catch {}
+    }
+  }
+}
+function toRelativePath(root, filename) {
+  const relativePath = isAbsolute3(filename) ? relative3(root, filename) : filename.split("\\").join("/");
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../")) {
+    return;
+  }
+  return relativePath.split("\\").join("/");
+}
+function isRecursiveWatchUnsupported(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === RECURSIVE_WATCH_UNSUPPORTED_ERROR;
+}
+
+// src/server.ts
+var DEVELOPMENT_URL_PREFIX = "/dev";
+var INVALID_DEVELOPMENT_DIRECTORY_MESSAGE = "Development output must be a subdirectory of the project root";
+var LIVE_RELOAD_PATH = "/__transone/reload";
+var WATCHED_EXTENSIONS = new Set([
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".css",
+  ".html"
+]);
+var IGNORED_WATCH_SEGMENTS = new Set([
+  "dist",
+  "node_modules",
+  ".git",
+  ".worktrees"
+]);
+var LIVE_RELOAD_CLIENT_SCRIPT = [
+  '<script type="module">',
+  "const transoneReloadSource=new EventSource(",
+  JSON.stringify(LIVE_RELOAD_PATH),
+  ");",
+  'transoneReloadSource.addEventListener("reload",()=>location.reload());',
+  "</script>"
+].join("");
+async function startDevServer(options = {}) {
+  if (options.watch) {
+    return startWatchingDevServer(options);
+  }
+  const instance = await createServerInstance(options, false);
+  return instance.server;
+}
+async function startWatchingDevServer(options) {
+  let instance = await createServerInstance(options, true);
+  let watcher = createProjectWatcher(instance, onChange);
+  async function onChange(changedPath) {
+    const configFile = instance.config.configFile;
+    const configRelativePath = configFile === undefined ? undefined : toRelativePath2(instance.config.root, configFile);
+    if (configRelativePath === changedPath) {
+      await restart();
+      return;
+    }
+    await rebuildAndReload();
+  }
+  async function rebuildAndReload() {
+    const entries = [...new Set(Object.values(instance.config.pages))];
+    instance.markDirty(entries);
+    for (const entry of entries) {
+      const bundle = await instance.getBundle(entry);
+      if (bundle instanceof Response) {
+        console.error("TransOne rebuild failed; keeping the last working page.");
+        return;
+      }
+    }
+    instance.liveReload?.broadcast();
+  }
+  async function restart() {
+    watcher.dispose();
+    instance.server.stop(true);
+    instance = await createServerInstance(options, true);
+    watcher = createProjectWatcher(instance, onChange);
+    console.log(`TransOne dev server restarted at http://${instance.server.hostname}:${instance.server.port}`);
+  }
+  return createServerHandle(() => instance, () => watcher.dispose());
+}
+function createProjectWatcher(instance, onChange) {
+  return createFileWatcher({
+    root: instance.config.root,
+    isRelevant: (relativePath) => isWatchedFile(instance, relativePath),
+    onChange: (changedPath) => {
+      onChange(changedPath);
+    }
+  });
+}
+async function createServerInstance(options, watch2) {
+  const config = await resolveConfig(options);
+  const { renderProjectHtml } = await import("./project-ybacfze8.js");
+  for (const [route, entry] of Object.entries(config.pages)) {
+    await renderProjectHtml(config, {}, entry, route);
+  }
+  const developmentOutDir = resolve5(config.root, "dist", "dev", "h5");
+  await assertSafeSubdirectory(config.root, developmentOutDir, INVALID_DEVELOPMENT_DIRECTORY_MESSAGE);
+  const proxy = createProxyHandler(config.server.proxy);
+  const sessionId = createGenerationId();
+  const sessionOutDir = resolve5(developmentOutDir, sessionId);
+  const artifacts = new Map;
+  const buildProject = createDevelopmentBuilder(sessionId, sessionOutDir);
+  const liveReload = watch2 ? createLiveReloadHub() : undefined;
+  const bundles = new Map;
+  const dirtyEntries = new Set;
+  const getBundle = async (entry) => {
+    const cached = bundles.get(entry);
+    if (watch2 && cached !== undefined && !dirtyEntries.has(entry)) {
+      return cached;
+    }
+    const bundle = await buildProject(entry);
+    if (bundle instanceof Response) {
+      if (watch2) {
+        dirtyEntries.add(entry);
+      }
+      return bundle;
+    }
+    if (watch2) {
+      bundles.set(entry, bundle);
+      dirtyEntries.delete(entry);
+    }
+    return bundle;
+  };
+  const server = Bun.serve({
+    hostname: config.server.host,
+    port: config.server.port,
+    fetch: async (request) => {
+      const reloadResponse = liveReload?.handleRequest(request);
+      if (reloadResponse) {
+        return reloadResponse;
+      }
+      return await proxy(request) ?? serveProjectRequest(request, config, config.pages, getBundle, artifacts, liveReload);
+    }
+  });
+  return {
+    server,
+    config,
+    getBundle,
+    markDirty: (entries) => {
+      entries.forEach((entry) => dirtyEntries.add(entry));
+    },
+    liveReload
+  };
+}
+function createServerHandle(getInstance, disposeWatcher) {
+  return new Proxy({}, {
+    get(_target, property) {
+      if (property === "stop") {
+        return (closeActiveConnections) => {
+          disposeWatcher();
+          getInstance().server.stop(closeActiveConnections);
+        };
+      }
+      const server = getInstance().server;
+      const value = server[property];
+      return typeof value === "function" ? value.bind(server) : value;
+    }
+  });
+}
+async function serveProjectRequest(request, config, pages, getBundle, artifacts, liveReload) {
+  const pathname = new URL(request.url).pathname;
+  const route = pageRouteForPathname(pages, pathname);
+  if (route !== undefined) {
+    const entry = pages[route];
+    const bundle = await getBundle(entry);
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      const { renderProjectHtml } = await import("./project-ybacfze8.js");
+      const html = await renderProjectHtml(config, {
+        head: bundle.stylesheets.map(({ pathname: href }) => ({
+          tag: "link",
+          attributes: { rel: "stylesheet", href }
+        })),
+        scripts: [{ type: "module", src: bundle.entry.pathname }]
+      }, entry, route);
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(liveReload ? injectLiveReloadScript(html) : html, {
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    }
+  }
+  if (pathname === "/bundle.js") {
+    const bundle = await getBundle(config.entry);
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(null, {
+        status: 307,
+        headers: {
+          location: bundle.entry.pathname,
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    }
+  }
+  const artifact = artifacts.get(pathname);
+  if (artifact) {
+    return new Response(Bun.file(artifact.filePath), {
+      headers: {
+        "content-type": artifact.type,
+        "cache-control": "no-store"
+      }
+    });
+  }
+  return new Response("Not found", {
+    status: 404,
+    headers: { "cache-control": "no-store" }
+  });
+}
+function pageRouteForPathname(pages, pathname) {
+  if (pages[pathname] !== undefined) {
+    return pathname;
+  }
+  if (pathname === "/index.html") {
+    return "/";
+  }
+  const candidate = pathname.length > 1 && pathname.endsWith("/") ? pathname.replace(/\/+$/, "") : pathname;
+  if (pages[candidate] !== undefined) {
+    return candidate;
+  }
+  if (candidate.endsWith("/index.html")) {
+    const base = candidate.slice(0, candidate.length - "/index.html".length);
+    if (base === "") {
+      return "/";
+    }
+    if (pages[base] !== undefined) {
+      return base;
+    }
+  }
+  return;
+}
+function injectLiveReloadScript(html) {
+  if (html.includes(LIVE_RELOAD_PATH)) {
+    return html;
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${LIVE_RELOAD_CLIENT_SCRIPT}</body>`);
+  }
+  return html + LIVE_RELOAD_CLIENT_SCRIPT;
+}
+var reloadEncoder = new TextEncoder;
+function createLiveReloadHub() {
+  const controllers = new Set;
+  function handleRequest(request) {
+    if (new URL(request.url).pathname !== LIVE_RELOAD_PATH) {
+      return;
+    }
+    let streamController;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+        controllers.add(controller);
+        try {
+          controller.enqueue(reloadEncoder.encode(`: connected
+
+`));
+        } catch {
+          controllers.delete(controller);
+        }
+      },
+      cancel: () => {
+        if (streamController) {
+          controllers.delete(streamController);
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store"
+      }
+    });
+  }
+  function broadcast() {
+    const message = reloadEncoder.encode(`event: reload
+data: {}
+
+`);
+    for (const controller of [...controllers]) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        controllers.delete(controller);
+      }
+    }
+  }
+  return { handleRequest, broadcast };
+}
+function isWatchedFile(instance, relativePath) {
+  if (relativePath === "" || relativePath.startsWith("..")) {
+    return false;
+  }
+  const segments = relativePath.split("/");
+  if (segments.some((segment) => IGNORED_WATCH_SEGMENTS.has(segment))) {
+    return false;
+  }
+  const absolutePath = resolve5(instance.config.root, relativePath);
+  if (isWithinOrEqual(instance.config.build.outDir, absolutePath)) {
+    return false;
+  }
+  const base = basename2(absolutePath);
+  if (base.startsWith(".") && absolutePath !== instance.config.configFile) {
+    return false;
+  }
+  return WATCHED_EXTENSIONS.has(extname(base).toLowerCase());
+}
+function toRelativePath2(root, absolutePath) {
+  return relative4(root, absolutePath).split(sep3).join("/");
+}
+function isWithinOrEqual(parent, candidate) {
+  const pathFromParent = relative4(parent, candidate);
+  return pathFromParent === "" || pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep3}`) && !isAbsolute4(pathFromParent);
+}
+function createDevelopmentBuilder(sessionId, sessionOutDir) {
+  let queue = Promise.resolve();
+  return (entry) => {
+    const result = queue.then(() => buildProjectBundle(entry, sessionId, sessionOutDir));
+    queue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+}
+async function buildProjectBundle(entry, sessionId, sessionOutDir) {
+  const generationId = createGenerationId();
+  const generationOutDir = resolve5(sessionOutDir, generationId);
+  const generationUrl = `${DEVELOPMENT_URL_PREFIX}/${sessionId}/${generationId}`;
+  const buildOptions = {
+    entrypoints: [entry],
+    outdir: generationOutDir,
+    target: "browser",
+    format: "esm",
+    sourcemap: "inline",
+    write: true,
+    throw: false,
+    publicPath: `${generationUrl}/`,
+    naming: {
+      entry: "[name]-[hash].[ext]",
+      chunk: "[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  };
+  try {
+    const result = await Bun.build(buildOptions);
+    const entryArtifact = result.outputs.find(isEntryJavaScriptOutput);
+    if (!result.success || !entryArtifact) {
+      result.logs.forEach((log) => console.error(log));
+      if (!entryArtifact) {
+        console.error("Failed to build project bundle: no JavaScript output");
+      }
+      return buildFailureResponse();
+    }
+    const pendingArtifacts = new Map;
+    const outputs = new Map;
+    for (const output of result.outputs) {
+      const developmentOutput = createDevelopmentOutput(generationOutDir, generationUrl, output);
+      if (pendingArtifacts.has(developmentOutput.pathname)) {
+        throw new Error(`Development output URL collision: ${developmentOutput.pathname}`);
+      }
+      pendingArtifacts.set(developmentOutput.pathname, developmentOutput);
+      outputs.set(output, developmentOutput);
+    }
+    const entry2 = outputs.get(entryArtifact);
+    if (!entry2) {
+      throw new Error("Development entry output was not indexed");
+    }
+    return {
+      entry: entry2,
+      stylesheets: result.outputs.filter(isStylesheetOutput).map((output) => outputs.get(output)).filter((output) => output !== undefined),
+      artifacts: pendingArtifacts
+    };
+  } catch (error) {
+    console.error(error);
+    return buildFailureResponse();
+  }
+}
+function publishDevelopmentBundle(bundle, artifacts) {
+  for (const [pathname, output] of bundle.artifacts) {
+    const existing = artifacts.get(pathname);
+    if (existing) {
+      if (existing.filePath === output.filePath) {
+        continue;
+      }
+      throw new Error(`Development output URL collision: ${pathname}`);
+    }
+    artifacts.set(pathname, output);
+  }
+}
+function createDevelopmentOutput(generationOutDir, generationUrl, output) {
+  const filePath = resolve5(output.path);
+  const pathFromGeneration = relative4(generationOutDir, filePath);
+  if (pathFromGeneration === "" || pathFromGeneration === ".." || pathFromGeneration.startsWith(`..${sep3}`) || isAbsolute4(pathFromGeneration)) {
+    throw new Error(`Development output must not escape outside its generation directory: ${output.path}`);
+  }
+  const urlPath = pathFromGeneration.split(sep3).map((segment) => encodeURIComponent(segment)).join("/");
+  return {
+    filePath,
+    pathname: `${generationUrl}/${urlPath}`,
+    type: output.type
+  };
+}
+function createGenerationId() {
+  return randomUUID().replace(/-/g, "");
+}
+function buildFailureResponse() {
+  return new Response("Failed to build project bundle", {
+    status: 500,
+    headers: { "cache-control": "no-store" }
+  });
+}
+
+export { TARGET_TYPES, isTargetType, defineConfig, resolveConfig, WebTarget, PlaceholderTarget, TargetRegistry, targetRegistry, build, createProject, startDevServer };
+
+//# debugId=312AA42B6393002164756E2164756E21
+//# sourceMappingURL=index-30n2h2ep.js.map