@mnaoumov/create-obsidian-plugin 0.0.0-stage → 1.0.1

package/dist/main.js

@@ -0,0 +1,4184 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import {
+  cancel as cancel3,
+  confirm,
+  intro,
+  log as log4,
+  note,
+  outro,
+  select as select2,
+  spinner,
+  text as text2
+} from "@clack/prompts";
+import { spawn } from "node:child_process";
+import {
+  chmodSync,
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import {
+  join as join5,
+  resolve as resolvePath
+} from "node:path";
+import { compare } from "semver";
+
+// src/cli-args.ts
+import {
+  existsSync,
+  readFileSync
+} from "node:fs";
+
+// src/clack-select.ts
+import {
+  SelectPrompt,
+  settings
+} from "@clack/core";
+import {
+  S_BAR,
+  S_BAR_END,
+  S_RADIO_ACTIVE,
+  S_RADIO_INACTIVE,
+  symbol
+} from "@clack/prompts";
+import { styleText } from "node:util";
+
+// src/clack-utils.ts
+import {
+  cancel,
+  isCancel
+} from "@clack/prompts";
+var lastCancelWasEscape = false;
+var GoBackError = class extends Error {
+  constructor() {
+    super("Go back");
+  }
+};
+function assertNotCancelled(value) {
+  if (isCancel(value)) {
+    cancel("Operation cancelled.");
+    process.exit(0);
+  }
+}
+function resetCancelFlag() {
+  lastCancelWasEscape = false;
+}
+function setEscapeCancel() {
+  lastCancelWasEscape = true;
+}
+function throwGoBackOnCancel(value) {
+  if (isCancel(value)) {
+    if (lastCancelWasEscape) {
+      lastCancelWasEscape = false;
+      throw new GoBackError();
+    }
+    cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+// src/clack-select.ts
+async function select(opts) {
+  const selectOpts = {
+    options: opts.options,
+    render() {
+      const withGuide = settings.withGuide;
+      const header = `${withGuide ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${opts.message}
+`;
+      const selected = this.options[this.cursor];
+      switch (this.state) {
+        case "cancel": {
+          const bar = withGuide ? `${styleText("gray", S_BAR)}  ` : "";
+          const label = selected?.label ?? "";
+          return `${header}${bar}${styleText(["strikethrough", "dim"], label)}${withGuide ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        case "submit": {
+          const bar = withGuide ? `${styleText("gray", S_BAR)}  ` : "";
+          const label = selected?.label ?? "";
+          return `${header}${bar}${styleText("dim", label)}`;
+        }
+        default: {
+          const bar = withGuide ? `${styleText("cyan", S_BAR)}  ` : "";
+          const barEnd = withGuide ? styleText("cyan", S_BAR_END) : "";
+          const lines = this.options.map((opt, i) => {
+            const o = opt;
+            const isActive = i === this.cursor;
+            const radio = isActive ? styleText("green", S_RADIO_ACTIVE) : styleText("dim", S_RADIO_INACTIVE);
+            const label = isActive ? o.label : styleText("dim", o.label);
+            const hint = o.hint && isActive ? ` ${styleText("dim", `(${o.hint})`)}` : "";
+            return `${radio} ${label}${hint}`;
+          });
+          return `${header}${lines.map((line) => `${bar}${line}`).join("\n")}
+${barEnd}
+`;
+        }
+      }
+    }
+  };
+  if (opts.initialValue !== void 0) {
+    selectOpts.initialValue = opts.initialValue;
+  }
+  const prompt = new SelectPrompt(selectOpts);
+  prompt.on("key", (_char, key) => {
+    if (key.name === "escape") {
+      setEscapeCancel();
+    }
+  });
+  resetCancelFlag();
+  const result = await prompt.prompt();
+  return throwGoBackOnCancel(result) ?? "";
+}
+
+// src/feature-option.ts
+var FeatureOption = class {
+  jsxImportSource;
+  partialName;
+  promptHint;
+  promptLabel;
+  settingValue;
+  constructor(config) {
+    this.settingValue = config.settingValue;
+    this.jsxImportSource = config.jsxImportSource;
+    this.partialName = config.partialName ?? config.settingValue;
+    this.promptLabel = config.promptLabel;
+    this.promptHint = config.promptHint;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Base no-op; subclasses override.
+  configure(_builder, _answers) {
+  }
+};
+async function promptFeature(params) {
+  const result = await select({
+    initialValue: params.savedValue ?? params.defaultOption.settingValue,
+    message: params.message,
+    options: params.options.map((o) => ({ hint: o.promptHint, label: o.promptLabel, value: o.settingValue }))
+  });
+  return result;
+}
+function resolveFeature(options, value) {
+  const option = options.find((o) => o.settingValue === value);
+  if (!option) {
+    throw new Error(`Unknown feature value: ${value}`);
+  }
+  return option;
+}
+
+// src/features/api-subset/official.ts
+var Official = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Stable, documented API only", promptLabel: "Official API", settingValue: "official" });
+  }
+};
+
+// src/features/api-subset/with-unofficial.ts
+var WithUnofficial = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Includes internal undocumented APIs (for experienced devs)", promptLabel: "Official + Unofficial", settingValue: "with-unofficial" });
+  }
+  configure(builder) {
+    builder.addPackage("@obsidian-typings/obsidian-public-latest");
+  }
+};
+
+// src/features/api-subset/index.ts
+var API_SUBSET_OPTIONS = [new Official(), new WithUnofficial()];
+async function promptApiSubset(savedValue) {
+  return promptFeature({ defaultOption: new Official(), message: "Obsidian API subset", options: API_SUBSET_OPTIONS, savedValue });
+}
+
+// src/features/preset/is-dev-utils-preset.ts
+var DEV_UTILS_PRESETS = /* @__PURE__ */ new Set(["demo", "enhanced"]);
+function isDevUtilsPreset(preset) {
+  return DEV_UTILS_PRESETS.has(preset);
+}
+
+// src/features/bundler/esbuild.ts
+var Esbuild = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast and simple (recommended)", promptLabel: "esbuild", settingValue: "esbuild" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("esbuild");
+    if (isDevUtilsPreset(answers.preset)) {
+      builder.addFiles(["scripts/esbuild-plugins.ts"]);
+    }
+  }
+};
+
+// src/features/bundler/parcel.ts
+var Parcel = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Zero-config bundler", promptLabel: "Parcel", settingValue: "parcel" });
+  }
+  configure(builder) {
+    builder.addPackage("parcel").addDepcheckIgnore("parcel", "run as a CLI by the build script.").addPackage("@parcel/config-default").addDepcheckIgnore("@parcel/config-default", "extended by name in `.parcelrc`.").addPackage("@parcel/plugin").addFiles([
+      ".parcelrc",
+      "parcel-namer-obsidian.cjs",
+      "parcel-resolver-obsidian.cjs",
+      "parcel-transformer-inline-imports.cjs"
+    ]);
+    builder.addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/rollup.ts
+var Rollup = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Flexible with plugin ecosystem", promptLabel: "Rollup", settingValue: "rollup" });
+  }
+  configure(builder) {
+    builder.addPackage("@rollup/plugin-commonjs").addPackage("@rollup/plugin-node-resolve").addPackage("@rollup/plugin-typescript").addPackage("@rollup/plugin-terser").addPackage("rollup").addFiles([
+      "rollup.config.mjs",
+      "scripts/rollup.config.ts"
+    ]);
+    builder.addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/vite.ts
+var Vite = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Modern dev server with HMR", promptLabel: "Vite", settingValue: "vite" });
+  }
+  configure(builder) {
+    builder.addPackage("vite").addFiles([
+      "vite.config.ts",
+      "scripts/vite.config.ts"
+    ]);
+    builder.addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/webpack.ts
+var Webpack = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Mature bundler with broad plugin support", promptLabel: "Webpack", settingValue: "webpack" });
+  }
+  configure(builder) {
+    builder.addPackage("webpack").addPackage("webpack-cli").addDepcheckIgnore("webpack-cli", "what `npx webpack` in the build script runs.").addPackage("terser-webpack-plugin").addPackage("ts-loader").addDepcheckIgnore("ts-loader", "named as a loader string in `scripts/webpack.config.ts`.").addFiles([
+      "webpack.config.ts",
+      "scripts/webpack.config.ts"
+    ]);
+    builder.addPartial("cli-bundler");
+  }
+};
+
+// src/features/bundler/index.ts
+var BUNDLER_OPTIONS = [new Esbuild(), new Parcel(), new Rollup(), new Vite(), new Webpack()];
+async function promptBundler(savedValue) {
+  return promptFeature({ defaultOption: new Esbuild(), message: "Bundler", options: BUNDLER_OPTIONS, savedValue });
+}
+
+// src/features/git-hooks.ts
+function addHusky(builder) {
+  builder.addPackage("husky").addDepcheckIgnore("husky", "run as a CLI by `scripts/prepare.ts`; the hooks in `.husky/` are its output.").addScript("prepare").addFiles(["scripts/prepare.ts"]);
+}
+function addStagedFilesHook(builder) {
+  addHusky(builder);
+  builder.addPackage("nano-staged").addDepcheckIgnore("nano-staged", "`.husky/pre-commit` runs it; configured by `scripts/nano-staged-config.ts`.").addFiles([
+    ".husky/pre-commit",
+    ".nano-staged.mjs",
+    "scripts/nano-staged-config.ts"
+  ]);
+}
+
+// src/features/commit-linting/conventional-commits.ts
+var ConventionalCommits = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "commitlint + a husky commit-msg hook", promptLabel: "Conventional Commits", settingValue: "conventional-commits" });
+  }
+  configure(builder) {
+    addHusky(builder);
+    builder.addPackage("@commitlint/cli").addDepcheckIgnore("@commitlint/cli", "`.husky/commit-msg` runs it as the `commitlint` binary.").addPackage("@commitlint/config-conventional").addDepcheckIgnore("@commitlint/config-conventional", "extended by name (a string in the `extends` of `scripts/commitlint-config.ts`), never imported.").addPackage("@commitlint/types").addPackage("czg").addDepcheckIgnore("czg", "run as a CLI by `scripts/commit.ts`.").addScript("commit").addFiles([
+      "commitlint.config.ts",
+      "scripts/commit.ts",
+      "scripts/commitlint-config.ts",
+      ".husky/commit-msg"
+    ]);
+  }
+};
+
+// src/features/commit-linting/none.ts
+var None = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No commit linting", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/commit-linting/index.ts
+var COMMIT_LINTING_OPTIONS = [new None(), new ConventionalCommits()];
+async function promptCommitLinting(savedValue) {
+  return promptFeature({ defaultOption: new ConventionalCommits(), message: "Commit linting", options: COMMIT_LINTING_OPTIONS, savedValue });
+}
+
+// src/features/coverage-badge/coverage-badge.ts
+var CoverageBadge = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: 'A "coverage: 100%" README badge', promptLabel: "Coverage badge", settingValue: "coverage-badge" });
+  }
+  configure(builder, answers) {
+    builder.addBadge(
+      `[![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/${answers.authorGitHubName}/obsidian-${answers.pluginId})`
+    );
+  }
+};
+
+// src/features/coverage-badge/none.ts
+var None2 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No coverage badge", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/coverage-badge/index.ts
+var COVERAGE_BADGE_OPTIONS = [new None2(), new CoverageBadge()];
+async function promptCoverageBadge(savedValue) {
+  return promptFeature({ defaultOption: new None2(), message: "Coverage badge", options: COVERAGE_BADGE_OPTIONS, savedValue });
+}
+
+// src/features/e2e-test-runner/none.ts
+var None3 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No E2E testing", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/e2e-test-runner/obsidian-test.ts
+var ObsidianTest = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Tests run inside Obsidian with real app APIs", promptLabel: "obsidian-test", settingValue: "obsidian-test" });
+  }
+  configure(builder) {
+    builder.addPackage("obsidian-test").addScript("test:e2e").addFiles([
+      "e2e/sample.spec.ts",
+      "scripts/test-e2e.ts"
+    ]).addPartial("has-e2e");
+  }
+};
+
+// src/features/e2e-test-runner/wdio-obsidian.ts
+var WdioObsidian = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "WebdriverIO service for Obsidian, multi-version & CI/CD", promptLabel: "wdio-obsidian", settingValue: "wdio-obsidian" });
+  }
+  configure(builder) {
+    builder.addPackage("@wdio/cli").addDepcheckIgnore("@wdio/cli", "run as the `wdio` CLI by `scripts/test-e2e.ts`.").addPackage("@wdio/globals").addPackage("@wdio/mocha-framework").addPackage("expect-webdriverio").addPackage("wdio-obsidian-service").addScript("test:e2e").addFiles([
+      "wdio.conf.ts",
+      "e2e/sample.spec.ts",
+      "scripts/test-e2e.ts"
+    ]).addPartial("has-e2e");
+  }
+};
+
+// src/features/e2e-test-runner/index.ts
+var E2E_TEST_RUNNER_OPTIONS = [new None3(), new ObsidianTest(), new WdioObsidian()];
+async function promptE2eTestRunner(savedValue) {
+  return promptFeature({ defaultOption: new None3(), message: "E2E testing", options: E2E_TEST_RUNNER_OPTIONS, savedValue });
+}
+
+// src/features/editor-extensions/code-mirror.ts
+var CodeMirror = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "CodeMirror 6 state fields, view plugins, decorations", promptLabel: "CodeMirror", settingValue: "codemirror" });
+  }
+  configure(builder) {
+    builder.addPackage("@codemirror/state").addPackage("@codemirror/view").addFiles([
+      "src/editor-extensions/sample-state-field.ts",
+      "src/editor-extensions/sample-view-plugin.ts",
+      "src/editor-extensions/sample-widget.ts",
+      "src/editor-suggests/sample-editor-suggest.ts"
+    ]);
+  }
+};
+
+// src/features/editor-extensions/none.ts
+var None4 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No editor extensions", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/editor-extensions/index.ts
+var EDITOR_EXTENSIONS_OPTIONS = [new None4(), new CodeMirror()];
+async function promptEditorExtensions(savedValue) {
+  return promptFeature({ defaultOption: new None4(), message: "Editor extensions", options: EDITOR_EXTENSIONS_OPTIONS, savedValue });
+}
+
+// src/features/formatter/biome.ts
+var Biome = class extends FeatureOption {
+  constructor() {
+    super({ partialName: "biome-formatter", promptHint: "Fast formatter (pairs with Biome linter)", promptLabel: "Biome", settingValue: "biome" });
+  }
+  configure(builder, answers) {
+    if (answers.linter !== "biome") {
+      builder.addLintStagedCommand("*.{ts,tsx,mts}", "biome format --write --no-errors-on-unmatched");
+    }
+    builder.addPackage("@biomejs/biome").addDepcheckIgnore("@biomejs/biome", "run as the `biome` CLI by the format and lint scripts, configured by `biome.jsonc`.").addScript("format").addScript("format:check").addFiles([
+      "biome.jsonc",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
+  }
+};
+
+// src/features/formatter/dprint.ts
+var Dprint = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast, pluggable, written in Rust", promptLabel: "dprint", settingValue: "dprint" });
+  }
+  configure(builder) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "dprint fmt").addPackage("dprint").addDepcheckIgnore("dprint", "run as a CLI by the format scripts, configured by `dprint.json`.").addScript("format").addScript("format:check").addFiles([
+      "dprint.json",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
+  }
+};
+
+// src/features/formatter/none.ts
+var None5 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No formatting", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/formatter/prettier.ts
+var Prettier = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Opinionated, widely adopted", promptLabel: "Prettier", settingValue: "prettier" });
+  }
+  configure(builder) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "prettier --write").addPackage("prettier").addScript("format").addScript("format:check").addFiles([
+      ".prettierignore",
+      "prettier.config.mjs",
+      "scripts/prettier.config.ts",
+      "scripts/format.ts",
+      "scripts/format-check.ts"
+    ]);
+  }
+};
+
+// src/features/formatter/index.ts
+var FORMATTER_OPTIONS = [new None5(), new Biome(), new Dprint(), new Prettier()];
+var FORMATTERS_NEEDING_INITIAL_FORMAT = /* @__PURE__ */ new Set(["biome", "prettier"]);
+function needsInitialFormat(formatter) {
+  return FORMATTERS_NEEDING_INITIAL_FORMAT.has(formatter);
+}
+async function promptFormatter(savedValue) {
+  return promptFeature({ defaultOption: new Dprint(), message: "Formatter", options: FORMATTER_OPTIONS, savedValue });
+}
+
+// src/features/funding-platform/funding-platform-option.ts
+var FundingPlatformOption = class extends FeatureOption {
+  badgeColor;
+  badgeLabel;
+  badgeLogo;
+  badgeLogoColor;
+  fundingYmlKey;
+  constructor(config) {
+    super({ promptHint: config.promptHint, promptLabel: config.promptLabel, settingValue: config.settingValue });
+    this.badgeColor = config.badgeColor;
+    this.badgeLabel = config.badgeLabel;
+    this.badgeLogo = config.badgeLogo;
+    this.badgeLogoColor = config.badgeLogoColor;
+    this.fundingYmlKey = config.fundingYmlKey;
+  }
+  /** The shields.io badge, as one markdown image link to {@link getUrl}. */
+  getBadge(answers) {
+    const label = encodeURIComponent(this.badgeLabel.replaceAll("-", "--").replaceAll("_", "__"));
+    let query = "";
+    if (this.badgeLogo !== void 0) {
+      query = `?logo=${this.badgeLogo}`;
+      if (this.badgeLogoColor !== void 0) {
+        query += `&logoColor=${this.badgeLogoColor}`;
+      }
+    }
+    return `[![${this.badgeLabel}](https://img.shields.io/badge/${label}-${this.badgeColor}${query})](${this.getUrl(answers)})`;
+  }
+  /** The value written after `<fundingYmlKey>: ` in `FUNDING.yml`. */
+  getFundingYmlValue(answers) {
+    return answers.fundingUsername;
+  }
+};
+
+// src/features/funding-platform/buy-me-a-coffee.ts
+var BuyMeACoffee = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ffdd00",
+      badgeLabel: "Buy Me a Coffee",
+      badgeLogo: "buy-me-a-coffee",
+      badgeLogoColor: "black",
+      fundingYmlKey: "buy_me_a_coffee",
+      promptHint: "buymeacoffee.com/<username>",
+      promptLabel: "Buy Me a Coffee",
+      settingValue: "buy-me-a-coffee"
+    });
+  }
+  getUrl(answers) {
+    return `https://www.buymeacoffee.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/custom.ts
+var Custom = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ff69b4",
+      badgeLabel: "Support",
+      fundingYmlKey: "custom",
+      promptHint: "Any other URL",
+      promptLabel: "Custom URL",
+      settingValue: "custom"
+    });
+  }
+  /** A one-element flow sequence, single-quoted so a URL's `#` or `: ` cannot end the scalar early. */
+  getFundingYmlValue(answers) {
+    return `['${answers.fundingUrl.replaceAll("'", "''")}']`;
+  }
+  getUrl(answers) {
+    return answers.fundingUrl;
+  }
+};
+
+// src/features/funding-platform/github-sponsors.ts
+var GitHubSponsors = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ea4aaa",
+      badgeLabel: "GitHub Sponsors",
+      badgeLogo: "githubsponsors",
+      badgeLogoColor: "white",
+      fundingYmlKey: "github",
+      promptHint: "github.com/sponsors/<username>",
+      promptLabel: "GitHub Sponsors",
+      settingValue: "github-sponsors"
+    });
+  }
+  getUrl(answers) {
+    return `https://github.com/sponsors/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/ko-fi.ts
+var KoFi = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "ff5e5b",
+      badgeLabel: "Ko-fi",
+      badgeLogo: "kofi",
+      badgeLogoColor: "white",
+      fundingYmlKey: "ko_fi",
+      promptHint: "ko-fi.com/<username>",
+      promptLabel: "Ko-fi",
+      settingValue: "ko-fi"
+    });
+  }
+  getUrl(answers) {
+    return `https://ko-fi.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/liberapay.ts
+var Liberapay = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "f6c915",
+      badgeLabel: "Liberapay",
+      badgeLogo: "liberapay",
+      badgeLogoColor: "black",
+      fundingYmlKey: "liberapay",
+      promptHint: "liberapay.com/<username>",
+      promptLabel: "Liberapay",
+      settingValue: "liberapay"
+    });
+  }
+  getUrl(answers) {
+    return `https://liberapay.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/none.ts
+var None6 = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "",
+      badgeLabel: "",
+      fundingYmlKey: "",
+      promptHint: "No funding link, FUNDING.yml or badge",
+      promptLabel: "(none)",
+      settingValue: "none"
+    });
+  }
+  getUrl() {
+    return "";
+  }
+};
+
+// src/features/funding-platform/open-collective.ts
+var OpenCollective = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "7fadf2",
+      badgeLabel: "Open Collective",
+      badgeLogo: "opencollective",
+      badgeLogoColor: "white",
+      fundingYmlKey: "open_collective",
+      promptHint: "opencollective.com/<username>",
+      promptLabel: "Open Collective",
+      settingValue: "open-collective"
+    });
+  }
+  getUrl(answers) {
+    return `https://opencollective.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/patreon.ts
+var Patreon = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "f96854",
+      badgeLabel: "Patreon",
+      badgeLogo: "patreon",
+      badgeLogoColor: "white",
+      fundingYmlKey: "patreon",
+      promptHint: "patreon.com/<username>",
+      promptLabel: "Patreon",
+      settingValue: "patreon"
+    });
+  }
+  getUrl(answers) {
+    return `https://www.patreon.com/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/polar.ts
+var Polar = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "0062ff",
+      badgeLabel: "Polar",
+      fundingYmlKey: "polar",
+      promptHint: "polar.sh/<username>",
+      promptLabel: "Polar",
+      settingValue: "polar"
+    });
+  }
+  getUrl(answers) {
+    return `https://polar.sh/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/thanks-dev.ts
+var ThanksDev = class extends FundingPlatformOption {
+  constructor() {
+    super({
+      badgeColor: "000000",
+      badgeLabel: "thanks.dev",
+      fundingYmlKey: "thanks_dev",
+      promptHint: "thanks.dev/<username>, e.g. u/gh/<GitHub username>",
+      promptLabel: "thanks.dev",
+      settingValue: "thanks-dev"
+    });
+  }
+  getUrl(answers) {
+    return `https://thanks.dev/${answers.fundingUsername}`;
+  }
+};
+
+// src/features/funding-platform/index.ts
+var FUNDING_PLATFORM_OPTIONS = [
+  new None6(),
+  new BuyMeACoffee(),
+  new GitHubSponsors(),
+  new KoFi(),
+  new Liberapay(),
+  new OpenCollective(),
+  new Patreon(),
+  new Polar(),
+  new ThanksDev(),
+  new Custom()
+];
+function asksFundingUsername(platform) {
+  return platform !== void 0 && platform !== "none" && platform !== "custom";
+}
+async function promptFundingPlatform(savedValue) {
+  return promptFeature({ defaultOption: new BuyMeACoffee(), message: "Funding platform", options: FUNDING_PLATFORM_OPTIONS, savedValue });
+}
+function resolveFunding(answers) {
+  const option = FUNDING_PLATFORM_OPTIONS.find((candidate) => candidate.settingValue === answers.fundingPlatform);
+  if (!option?.getUrl(answers)) {
+    return null;
+  }
+  return option;
+}
+function validateFundingUsername(value) {
+  if (!value) {
+    return "Should not be empty";
+  }
+  if (!/^[\w./-]+$/.test(value)) {
+    return "Use only letters, digits, `.`, `_`, `-` and `/`";
+  }
+  return void 0;
+}
+
+// src/features/git-hub-actions/ci-and-release.ts
+var CiAndRelease = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "CI + automated release on tag push", promptLabel: "CI + Release", settingValue: "ci-and-release" });
+  }
+  configure(builder) {
+    builder.addFiles([
+      ".github/workflows/ci.yml",
+      ".github/workflows/release.yml"
+    ]);
+  }
+};
+
+// src/features/git-hub-actions/ci-workflow.ts
+var CiWorkflow = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "CI workflow only (lint, test, build)", promptLabel: "CI", settingValue: "ci" });
+  }
+  configure(builder) {
+    builder.addFiles([".github/workflows/ci.yml"]);
+  }
+};
+
+// src/features/git-hub-actions/none.ts
+var None7 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No GitHub Actions workflows", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/git-hub-actions/index.ts
+var GITHUB_ACTIONS_OPTIONS = [new None7(), new CiAndRelease(), new CiWorkflow()];
+async function promptGitHubActions(savedValue) {
+  return promptFeature({ defaultOption: new CiAndRelease(), message: "GitHub Actions", options: GITHUB_ACTIONS_OPTIONS, savedValue });
+}
+
+// src/features/git-hub-issue-templates/bug-and-feature.ts
+var BugAndFeature = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Bug report and feature request templates", promptLabel: "Bug & Feature", settingValue: "bug-and-feature" });
+  }
+  // The real plugins' names, underscores and all. They used to be emitted as `bug-report.yml` and
+  // `feature-request.yml`, because any `_` in a basename was read as the partial marker and the render
+  // Loop silently skipped both forms; `isPartialTemplatePath` now reads only a kebab-case tail as one.
+  configure(builder) {
+    builder.addFiles([
+      ".github/ISSUE_TEMPLATE/bug_report.yml",
+      ".github/ISSUE_TEMPLATE/config.yml",
+      ".github/ISSUE_TEMPLATE/feature_request.yml"
+    ]);
+  }
+};
+
+// src/features/git-hub-issue-templates/none.ts
+var None8 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No issue templates", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/git-hub-issue-templates/index.ts
+var GITHUB_ISSUE_TEMPLATES_OPTIONS = [new None8(), new BugAndFeature()];
+async function promptGitHubIssueTemplates(savedValue) {
+  return promptFeature({ defaultOption: new BugAndFeature(), message: "GitHub issue templates", options: GITHUB_ISSUE_TEMPLATES_OPTIONS, savedValue });
+}
+
+// src/features/hot-reload/hot-reload-plugin.ts
+var HotReloadPlugin = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Creates .hotreload marker for pjeby/hot-reload", promptLabel: "Hot Reload Plugin", settingValue: "hot-reload-plugin" });
+  }
+};
+
+// src/features/hot-reload/none.ts
+var None9 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No hot reload support", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/hot-reload/obsidian-cli.ts
+var ObsidianCli = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Reloads via obsidian plugin:reload CLI command", promptLabel: "Obsidian CLI", settingValue: "obsidian-cli" });
+  }
+};
+
+// src/features/hot-reload/index.ts
+var HOT_RELOAD_OPTIONS = [new None9(), new HotReloadPlugin(), new ObsidianCli()];
+async function promptHotReload(savedValue) {
+  return promptFeature({ defaultOption: new ObsidianCli(), message: "Hot reload", options: HOT_RELOAD_OPTIONS, savedValue });
+}
+
+// src/features/internationalization/i18next.ts
+var I18next = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Popular i18n framework with JSON translations", promptLabel: "i18next", settingValue: "i18next" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("i18next").addFiles([
+      "src/i18n/index.ts",
+      "src/i18n/locales/en.json"
+    ]);
+    if (answers.bundler === "rollup") {
+      builder.addPackage("@rollup/plugin-json").addPartial("rollup-json");
+    }
+  }
+};
+
+// src/features/internationalization/none.ts
+var None10 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No internationalization", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/internationalization/typesafe-i18n.ts
+var TypesafeI18n = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Type-safe i18n with auto-generated types", promptLabel: "typesafe-i18n", settingValue: "typesafe-i18n" });
+  }
+  configure(builder) {
+    builder.addPackage("typesafe-i18n").addFiles([
+      "src/i18n/index.ts",
+      "src/i18n/en/index.ts",
+      ".typesafe-i18n.json"
+    ]);
+  }
+};
+
+// src/features/internationalization/index.ts
+var INTERNATIONALIZATION_OPTIONS = [new None10(), new I18next(), new TypesafeI18n()];
+async function promptInternationalization(savedValue) {
+  return promptFeature({ defaultOption: new None10(), message: "Internationalization", options: INTERNATIONALIZATION_OPTIONS, savedValue });
+}
+
+// src/features/linter/biome.ts
+var Biome2 = class extends FeatureOption {
+  constructor() {
+    super({ partialName: "biome-linter", promptHint: "Fast linter and formatter", promptLabel: "Biome", settingValue: "biome" });
+  }
+  configure(builder) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "biome check --write --no-errors-on-unmatched").addPackage("@biomejs/biome").addDepcheckIgnore("@biomejs/biome", "run as the `biome` CLI by the format and lint scripts, configured by `biome.jsonc`.").addScript("lint").addScript("lint:fix").addFiles([
+      "biome.jsonc",
+      "scripts/lint.ts",
+      "scripts/lint-fix.ts"
+    ]);
+  }
+};
+
+// src/features/linter/eslint.ts
+var Eslint = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Industry standard for JavaScript/TypeScript", promptLabel: "ESLint", settingValue: "eslint" });
+  }
+  configure(builder, answers) {
+    builder.addLintStagedCommand("*.{ts,tsx,mts}", "eslint --fix").addPackage("eslint").addPackage("typescript-eslint").addScript("lint").addScript("lint:fix").addFiles([
+      "eslint.config.mts",
+      "scripts/lint.ts",
+      "scripts/lint-fix.ts"
+    ]);
+    if (isDevUtilsPreset(answers.preset)) {
+      builder.addDepcheckIgnore("typescript-eslint", "imported by nothing here -- the shared config brings its own -- but the `typescript` pin's check reads its `package.json` for the peer range.").addFiles(["scripts/eslint-config.ts"]);
+      return;
+    }
+    builder.addPackage("@eslint/js").addPackage("eslint-plugin-obsidianmd").addPackage("globals");
+  }
+};
+
+// src/features/linter/none.ts
+var None11 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No linting", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/linter/index.ts
+var LINTER_OPTIONS = [new None11(), new Biome2(), new Eslint()];
+async function promptLinter(savedValue) {
+  return promptFeature({ defaultOption: new Eslint(), message: "Linter", options: LINTER_OPTIONS, savedValue });
+}
+
+// src/features/markdown-linter/markdownlint.ts
+var Markdownlint = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Lint Markdown files for style and consistency", promptLabel: "markdownlint", settingValue: "markdownlint" });
+  }
+  configure(builder, answers) {
+    builder.addLintStagedCommand("*.md", "markdownlint-cli2 --fix").addPackage("markdownlint-cli2").addDepcheckIgnore("markdownlint-cli2", "run as a CLI by the `lint:md` scripts, configured by `.markdownlint-cli2.mjs`.").addPackage("linkinator").addDepcheckIgnore("linkinator", "run as a CLI by the `lint:md` scripts.").addScript("lint:md").addScript("lint:md:fix").addFiles([
+      // `markdownlint-cli2` only discovers a config named `.markdownlint-cli2.{jsonc,yaml,cjs,mjs}`, and
+      // So does obsidian-dev-utils' runner -- which copies its own `.mjs` in when it finds none, pointing
+      // At a `scripts/markdownlint-cli2-config.ts` that then has to exist. Hence this shape rather than a
+      // Single `.mts` that nothing reads.
+      ".markdownlint-cli2.mjs",
+      "scripts/markdownlint-cli2-config.ts",
+      "scripts/lint-md.ts",
+      "scripts/lint-md-fix.ts",
+      // Read by linkinator from the project root under both presets; it skips the links to the plugin's own
+      // Repository, which 404 until the user pushes it.
+      "linkinator.config.json"
+    ]);
+    if (isDevUtilsPreset(answers.preset)) {
+      return;
+    }
+    builder.addPackage("markdownlint").addPackage("markdownlint-rule-relative-links");
+  }
+};
+
+// src/features/markdown-linter/none.ts
+var None12 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No Markdown linting", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/markdown-linter/index.ts
+var MARKDOWN_LINTER_OPTIONS = [new None12(), new Markdownlint()];
+async function promptMarkdownLinter(savedValue) {
+  return promptFeature({ defaultOption: new Markdownlint(), message: "Markdown linter", options: MARKDOWN_LINTER_OPTIONS, savedValue });
+}
+
+// src/features/package-manager/bun.ts
+var Bun = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast all-in-one JavaScript toolkit", promptLabel: "Bun", settingValue: "bun" });
+  }
+};
+
+// src/features/package-manager/npm.ts
+var Npm = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Default, comes with Node.js", promptLabel: "npm", settingValue: "npm" });
+  }
+};
+
+// src/features/package-manager/pnpm.ts
+var Pnpm = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast, efficient disk space", promptLabel: "pnpm", settingValue: "pnpm" });
+  }
+};
+
+// src/features/package-manager/yarn.ts
+var Yarn = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Classic alternative with workspaces", promptLabel: "Yarn", settingValue: "yarn" });
+  }
+};
+
+// src/features/package-manager/index.ts
+var PACKAGE_MANAGER_OPTIONS = [new Bun(), new Npm(), new Pnpm(), new Yarn()];
+function getInstallCommand(pm) {
+  return `${pm} install`;
+}
+function getRunCommand(pm, script) {
+  if (pm === "npm") {
+    return `npm run ${script}`;
+  }
+  if (pm === "yarn") {
+    return `yarn ${script}`;
+  }
+  if (pm === "pnpm") {
+    return `pnpm ${script}`;
+  }
+  return `bun run ${script}`;
+}
+async function promptPackageManager(savedValue) {
+  return promptFeature({ defaultOption: new Npm(), message: "Package manager", options: PACKAGE_MANAGER_OPTIONS, savedValue });
+}
+
+// src/features/platform-support/desktop-and-mobile.ts
+var DesktopAndMobile = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Plugin works on desktop and mobile", promptLabel: "Desktop and mobile", settingValue: "desktop-and-mobile" });
+  }
+};
+
+// src/features/platform-support/desktop-only.ts
+var DesktopOnly = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Plugin works only on desktop", promptLabel: "Desktop only", settingValue: "desktop-only" });
+  }
+};
+
+// src/features/platform-support/index.ts
+var PLATFORM_SUPPORT_OPTIONS = [new DesktopAndMobile(), new DesktopOnly()];
+async function promptPlatformSupport(savedValue) {
+  return promptFeature({ defaultOption: new DesktopOnly(), message: "Platform support", options: PLATFORM_SUPPORT_OPTIONS, savedValue });
+}
+
+// src/features/preset/demo-vault.ts
+var DEMO_VAULT_TEMPLATE_FILES = [
+  "demo-vault/.gitignore",
+  "demo-vault/.obsidian/app.json",
+  "demo-vault/.obsidian/community-plugins.json",
+  "demo-vault/00 Start.md",
+  "demo-vault/01 Sample commands.md",
+  "demo-vault/02 Settings.md",
+  "demo-vault/Materials/01 Sample commands/Scratch note.md",
+  "demo-vault/README.md",
+  "demo-vault/_assets/CodeScriptToolkit/demoSetup.ts",
+  "demo-vault/_assets/CodeScriptToolkit/startup.ts"
+];
+
+// src/features/preset/demo.ts
+var Demo = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "All features enabled for demonstration", promptLabel: "Demo", settingValue: "demo" });
+  }
+  configure(builder) {
+    builder.addPackage("@tsconfig/strictest").addPackage("moment").addDepcheckIgnore("moment", "imported through `obsidian` rather than directly, and the typings of `obsidian` resolve it by name.").addPackage("obsidian-dev-utils").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
+      // Not gated on the gitHubActions answer, and deliberately so: this attests the assets of a
+      // Published RELEASE, and the release flow is the preset's, not CI's. Every plugin compared here
+      // Ships this workflow -- they have no ci.yml at all.
+      ".github/workflows/attest-release-assets.yml",
+      // Not gated on the answers either: the shared ESLint config's `obsidianmd/validate-license` compares
+      // The LICENSE year with the current one, so without this bump every project turns red on 1 January.
+      ".github/workflows/update-license-year.yml",
+      "scripts/build.ts",
+      "scripts/build-clean.ts",
+      "scripts/build-compile.ts",
+      "scripts/find-overexposed.ts",
+      "scripts/find-overexposed-fix.ts",
+      "scripts/dev.ts",
+      "scripts/gate.ts",
+      "scripts/version.ts",
+      "src/modals/sample-form-modal.ts",
+      "src/modals/sample-suggest-modal.ts",
+      "src/plugin-settings.ts",
+      "src/plugin-settings-component.ts",
+      "src/plugin-settings-tab.ts",
+      "src/views/sample-view.ts",
+      ...DEMO_VAULT_TEMPLATE_FILES
+    ]).addPartial("dev-utils");
+  }
+};
+
+// src/features/preset/enhanced.ts
+var Enhanced = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Recommended. Uses obsidian-dev-utils for settings, linting, and more", promptLabel: "Enhanced", settingValue: "enhanced" });
+  }
+  configure(builder) {
+    builder.addPackage("@tsconfig/strictest").addPackage("obsidian-dev-utils").addPackage("obsidian-integration-testing").addScript("dev").addScript("build").addScript("build:clean").addScript("build:compile").addScript("find-overexposed").addScript("find-overexposed:fix").addScript("version").addScript("gate").addFiles([
+      // Not gated on the gitHubActions answer, and deliberately so: this attests the assets of a
+      // Published RELEASE, and the release flow is the preset's, not CI's. Every plugin compared here
+      // Ships this workflow -- they have no ci.yml at all.
+      ".github/workflows/attest-release-assets.yml",
+      // Not gated on the answers either: the shared ESLint config's `obsidianmd/validate-license` compares
+      // The LICENSE year with the current one, so without this bump every project turns red on 1 January.
+      ".github/workflows/update-license-year.yml",
+      "scripts/build.ts",
+      "scripts/build-clean.ts",
+      "scripts/build-compile.ts",
+      "scripts/find-overexposed.ts",
+      "scripts/find-overexposed-fix.ts",
+      "scripts/dev.ts",
+      "scripts/gate.ts",
+      "scripts/version.ts",
+      "src/plugin-settings.ts",
+      "src/plugin-settings-component.ts",
+      "src/plugin-settings-tab.ts",
+      ...DEMO_VAULT_TEMPLATE_FILES
+    ]).addPartial("dev-utils");
+  }
+};
+
+// src/features/preset/standalone.ts
+var Standalone = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Standalone plugin without obsidian-dev-utils dependency", promptLabel: "Standalone", settingValue: "standalone" });
+  }
+  configure(builder) {
+    builder.addScript("dev").addScript("build").addScript("version").addFiles([
+      "scripts/build.ts",
+      "scripts/dev.ts",
+      "scripts/version.ts",
+      "src/settings.ts"
+    ]);
+  }
+};
+
+// src/features/preset/index.ts
+var PRESET_OPTIONS = [new Demo(), new Enhanced(), new Standalone()];
+async function promptPreset(savedValue) {
+  return promptFeature({ defaultOption: new Enhanced(), message: "Choose a preset", options: PRESET_OPTIONS, savedValue });
+}
+
+// src/features/spell-checker/cspell.ts
+var Cspell = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Configurable spell checker for code", promptLabel: "cspell", settingValue: "cspell" });
+  }
+  configure(builder) {
+    builder.addPackage("cspell").addDepcheckIgnore("cspell", "run as a CLI by `scripts/spellcheck.ts`, configured by `cspell.json`.").addScript("spellcheck").addFiles([
+      "cspell.json",
+      "scripts/spellcheck.ts"
+    ]);
+  }
+};
+
+// src/features/spell-checker/none.ts
+var None13 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No spell checking", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/spell-checker/index.ts
+var SPELL_CHECKER_OPTIONS = [new None13(), new Cspell()];
+async function promptSpellChecker(savedValue) {
+  return promptFeature({ defaultOption: new Cspell(), message: "Spell checker", options: SPELL_CHECKER_OPTIONS, savedValue });
+}
+
+// src/features/styling/css-modules.ts
+var CssModules = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Scoped CSS with .module.css files", promptLabel: "CSS Modules", settingValue: "css-modules" });
+  }
+  configure(builder, answers) {
+    builder.addFiles([
+      "src/styles/main.module.css",
+      "src/styles/css-modules.d.ts"
+    ]);
+    if (answers.bundler === "rollup") {
+      builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPartial("webpack-css-extract");
+    }
+  }
+};
+
+// src/features/styling/css.ts
+var Css = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Plain CSS styles", promptLabel: "CSS", settingValue: "css" });
+  }
+  configure(builder, answers) {
+    builder.addFiles(["src/styles/main.css", "src/styles/styles.d.ts"]);
+    if (answers.bundler === "rollup") {
+      builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPartial("webpack-css-extract");
+    }
+  }
+};
+
+// src/features/styling/none.ts
+var None14 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No custom styles", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/styling/post-css.ts
+var PostCss = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "CSS with plugins (autoprefixer, nesting)", promptLabel: "PostCSS", settingValue: "postcss" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("autoprefixer").addPackage("postcss").addFiles([
+      "postcss.config.cjs",
+      "scripts/postcss.config.ts",
+      "src/styles/main.css",
+      "src/styles/styles.d.ts"
+    ]);
+    if (answers.bundler === "esbuild") {
+      builder.addPackage("esbuild-postcss");
+    }
+    if (answers.bundler === "rollup") {
+      builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPackage("postcss-loader").addDepcheckIgnore("postcss-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPartial("webpack-css-extract");
+    }
+  }
+};
+
+// src/features/styling/scss.ts
+var SCSS_PLUGINS = {
+  esbuild: "esbuild-sass-plugin",
+  parcel: "@parcel/transformer-sass",
+  rollup: "rollup-plugin-scss",
+  vite: "sass-embedded",
+  webpack: "sass-loader"
+};
+var SCSS_PLUGIN_DEPCHECK_REASONS = {
+  parcel: "resolved by name by `@parcel/config-default` for `.scss`; nothing imports it.",
+  vite: "the Sass compiler vite resolves by name for `.scss`; nothing imports it.",
+  webpack: "named as a loader string in `scripts/webpack.config.ts`."
+};
+var Scss = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Sass/SCSS preprocessor", promptLabel: "SCSS", settingValue: "scss" });
+  }
+  configure(builder, answers) {
+    builder.addFiles(["src/styles/main.scss", "src/styles/styles.d.ts"]);
+    const plugin = isDevUtilsPreset(answers.preset) && answers.bundler === "esbuild" ? void 0 : SCSS_PLUGINS[answers.bundler];
+    if (plugin) {
+      builder.addPackage(plugin);
+      const depcheckReason = SCSS_PLUGIN_DEPCHECK_REASONS[answers.bundler];
+      if (depcheckReason) {
+        builder.addDepcheckIgnore(plugin, depcheckReason);
+      }
+    }
+    if (answers.bundler === "esbuild") {
+      builder.addPackage("sass-embedded").addDepcheckIgnore("sass-embedded", "the Sass compiler `esbuild-sass-plugin` peers on; nothing imports it directly.");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPackage("sass").addDepcheckIgnore("sass", "the Sass compiler `sass-loader` resolves by name; nothing imports it directly.").addPartial("webpack-css-extract");
+    }
+  }
+};
+
+// src/features/styling/tailwind.ts
+var Tailwind = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Utility-first CSS framework", promptLabel: "Tailwind CSS", settingValue: "tailwind" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("@tailwindcss/cli").addDepcheckIgnore("@tailwindcss/cli", "run as a CLI by `scripts/build-styles.ts`.").addPackage("tailwindcss").addDepcheckIgnore("tailwindcss", 'imported by `src/styles/main.css` (`@import "tailwindcss"`), which depcheck does not read.').addScript("build:styles").addFiles([
+      "scripts/build-styles.ts",
+      "src/styles/main.css",
+      "src/styles/styles.d.ts"
+    ]);
+    if (answers.bundler === "rollup") {
+      builder.addPackage("rollup-plugin-postcss").addPartial("rollup-postcss");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("css-loader").addDepcheckIgnore("css-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("mini-css-extract-plugin").addPartial("webpack-css-extract");
+    }
+  }
+};
+
+// src/features/styling/index.ts
+var STYLING_OPTIONS = [new None14(), new Css(), new CssModules(), new PostCss(), new Scss(), new Tailwind()];
+async function promptStyling(savedValue) {
+  return promptFeature({ defaultOption: new Scss(), message: "Styling", options: STYLING_OPTIONS, savedValue });
+}
+
+// src/features/test-runner/sample-unit-tests.ts
+function addSampleUnitTests(builder, answers) {
+  builder.addFiles(["src/main.test.ts"]);
+  if (!isDevUtilsPreset(answers.preset)) {
+    return;
+  }
+  builder.addFiles(["src/plugin-settings-component.test.ts"]);
+  if (answers.preset === "demo") {
+    builder.addFiles(["src/plugin-settings.test.ts"]);
+  }
+}
+
+// src/features/test-runner/jest.ts
+var Jest = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Feature-rich, widely adopted", promptLabel: "Jest", settingValue: "jest" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("@types/jest").addPackage("jest").addPackage("jest-environment-jsdom").addDepcheckIgnore("jest-environment-jsdom", "named by `testEnvironment` in `jest.config.ts`, never imported.").addPackage("obsidian-test-mocks").addPackage("ts-jest").addScript("test").addScript("test:watch").addFiles([
+      "jest.config.ts",
+      "scripts/framework-component-stub.ts",
+      "scripts/stylesheet-stub.ts",
+      "scripts/wasm-module-stub.ts",
+      "src/plugin.test.ts",
+      "scripts/test.ts",
+      "scripts/test-watch.ts"
+    ]);
+    addSampleUnitTests(builder, answers);
+  }
+};
+
+// src/features/test-runner/none.ts
+var None15 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No unit testing", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/test-runner/vitest.ts
+var Vitest = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Fast, Vite-native, ESM-first", promptLabel: "Vitest", settingValue: "vitest" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("jsdom").addPackage("obsidian-test-mocks").addDepcheckIgnore(
+      "obsidian-test-mocks",
+      isDevUtilsPreset(answers.preset) ? "aliased and loaded as a setup file by name by `defineObsidianPluginVitestConfig` from obsidian-dev-utils." : "aliased and loaded as a setup file by name in `vitest.config.ts`."
+    ).addPackage("vitest").addScript("test").addScript("test:watch").addFiles([
+      "vitest.config.ts",
+      "src/plugin.test.ts",
+      "scripts/test.ts",
+      "scripts/test-watch.ts",
+      // Both presets, not just the dev-utils ones: the emitted `src/plugin.ts` reaches `src/wasm/answer.ts`
+      // On every preset when the `wasm` answer is chosen, so every vitest config aliases `.wasm` to
+      // This stub. `framework-component-stub.ts` is dev-utils-only because only those presets' `plugin.ts`
+      // Reaches a single-file component.
+      "scripts/wasm-module-stub.ts",
+      // `src/main.test.ts` imports `src/main.ts`, which imports the stylesheet -- and on `tailwind` that
+      // File does not exist until the first build. See the stub's own comment.
+      "scripts/stylesheet-stub.ts"
+    ]);
+    addSampleUnitTests(builder, answers);
+    if (!isDevUtilsPreset(answers.preset)) {
+      return;
+    }
+    builder.addPackage("@vitest/coverage-v8").addScript("test:coverage").addScript("test:integration").addScript("test:integration:android").addScript("test:integration:demo-vault").addScript("test:integration:desktop").addScript("test:integration:desktop:performance").addScript("test:integration:no-app").addFiles([
+      "scripts/test-integration-android.ts",
+      "scripts/test-integration-desktop.ts",
+      "scripts/test-integration-desktop-performance.ts",
+      "scripts/demo-vault-global-setup.ts",
+      "scripts/framework-component-stub.ts",
+      "scripts/test-coverage.ts",
+      "scripts/test-integration.ts",
+      "scripts/test-integration-demo-vault.ts",
+      "scripts/test-integration-no-app.ts",
+      "scripts/vitest-config.ts",
+      "src/demo-vault-buttons.demo-vault.integration.test.ts",
+      "src/demo-vault.no-app.integration.test.ts"
+    ]);
+  }
+};
+
+// src/features/test-runner/index.ts
+var TEST_RUNNER_OPTIONS = [new None15(), new Jest(), new Vitest()];
+async function promptTestRunner(savedValue) {
+  return promptFeature({ defaultOption: new Vitest(), message: "Unit testing", options: TEST_RUNNER_OPTIONS, savedValue });
+}
+
+// src/features/ui-framework/lit.ts
+var Lit = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Web Components with declarative templates", promptLabel: "Lit", settingValue: "lit" });
+  }
+  configure(builder) {
+    builder.addPackage("lit").addPartial("ui-view").addSentenceCaseBrand("Lit").addFiles([
+      "src/lit-elements/sample-lit-element.ts",
+      "src/views/sample-lit-view.ts"
+    ]);
+  }
+};
+
+// src/features/ui-framework/none.ts
+var None16 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Plain TypeScript, no UI framework", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/ui-framework/preact.ts
+var BUILD_PLUGINS = {
+  rollup: "@rollup/plugin-babel",
+  vite: "@preact/preset-vite"
+};
+var Preact = class extends FeatureOption {
+  constructor() {
+    super({ jsxImportSource: "preact", promptHint: "Lightweight React alternative (3kB)", promptLabel: "Preact", settingValue: "preact" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("preact").addPartial("ui-view").addSentenceCaseBrand("Preact").addFiles([
+      "src/preact-components/sample-preact-component.tsx",
+      "src/views/sample-preact-view.tsx"
+    ]);
+    const plugin = BUILD_PLUGINS[answers.bundler];
+    if (plugin) {
+      builder.addPackage(plugin);
+    }
+    if (answers.bundler === "rollup") {
+      builder.addPackage("@babel/core").addPackage("@babel/plugin-transform-react-jsx").addDepcheckIgnore("@babel/plugin-transform-react-jsx", "named as a string in `scripts/babel.config.ts`, never imported.").addFiles([
+        "babel.config.mjs",
+        "scripts/babel.config.ts"
+      ]).addPartial("rollup-babel");
+    }
+  }
+};
+
+// src/features/ui-framework/react.ts
+var BUILD_PLUGINS2 = {
+  rollup: "@rollup/plugin-babel",
+  vite: "@vitejs/plugin-react"
+};
+var React = class extends FeatureOption {
+  constructor() {
+    super({ jsxImportSource: "react", promptHint: "Component-based UI with JSX", promptLabel: "React", settingValue: "react" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("@types/react").addPackage("@types/react-dom").addPackage("react").addPackage("react-dom").addPartial("ui-view").addSentenceCaseBrand("React").addFiles([
+      "src/react-components/sample-react-component.tsx",
+      "src/views/sample-react-view.tsx"
+    ]);
+    const plugin = BUILD_PLUGINS2[answers.bundler];
+    if (plugin) {
+      builder.addPackage(plugin);
+    }
+    if (answers.bundler === "rollup") {
+      builder.addPackage("@babel/core").addPackage("@babel/preset-react").addDepcheckIgnore("@babel/preset-react", "named as a string in `scripts/babel.config.ts`, never imported.").addFiles([
+        "babel.config.mjs",
+        "scripts/babel.config.ts"
+      ]).addPartial("rollup-babel");
+    }
+  }
+};
+
+// src/features/ui-framework/solid.ts
+var BUILD_PLUGINS3 = {
+  rollup: "@rollup/plugin-babel",
+  vite: "vite-plugin-solid"
+};
+var Solid = class extends FeatureOption {
+  constructor() {
+    super({ jsxImportSource: "solid-js", promptHint: "Fine-grained reactivity, no virtual DOM", promptLabel: "Solid", settingValue: "solid" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("solid-js").addPartial("ui-view").addSentenceCaseBrand("Solid").addFiles([
+      "src/solid-components/sample-solid-component.tsx",
+      "src/views/sample-solid-view.tsx"
+    ]);
+    const plugin = BUILD_PLUGINS3[answers.bundler];
+    if (plugin) {
+      builder.addPackage(plugin);
+    }
+    if (answers.bundler === "rollup") {
+      builder.addPackage("@babel/core").addPackage("babel-preset-solid").addDepcheckIgnore("babel-preset-solid", "named as a string in `scripts/babel.config.ts`, never imported.").addFiles([
+        "babel.config.mjs",
+        "scripts/babel.config.ts"
+      ]).addPartial("rollup-babel");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addPackage("@babel/core").addDepcheckIgnore("@babel/core", "the peer dependency `babel-loader` loads, never imported.").addPackage("babel-loader").addDepcheckIgnore("babel-loader", "named as a loader string in `scripts/webpack.config.ts`.").addPackage("babel-preset-solid").addDepcheckIgnore("babel-preset-solid", "named as a string in `scripts/webpack.config.ts`, never imported.");
+    }
+    if (answers.bundler === "parcel") {
+      builder.addPackage("babel-preset-solid").addDepcheckIgnore("babel-preset-solid", "named as a string in `babel.config.json`, never imported.").addFiles(["babel.config.json"]);
+    }
+    if (answers.bundler === "esbuild") {
+      builder.addPackage("esbuild-plugin-solid");
+    }
+  }
+};
+
+// src/features/ui-framework/svelte.ts
+var BUILD_PLUGINS4 = {
+  esbuild: "esbuild-svelte",
+  parcel: null,
+  rollup: "rollup-plugin-svelte",
+  vite: "@sveltejs/vite-plugin-svelte",
+  webpack: "svelte-loader"
+};
+var SVELTE_PREPROCESS_BUNDLERS = /* @__PURE__ */ new Set(["esbuild", "rollup", "webpack"]);
+var Svelte = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Lightweight reactive components", promptLabel: "Svelte", settingValue: "svelte" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("svelte").addPartial("ui-view").addSentenceCaseBrand("Svelte").addFiles([
+      "src/svelte-components/sample-svelte-component.d.ts",
+      "src/svelte-components/sample-svelte-component.svelte",
+      "src/views/sample-svelte-view.ts"
+    ]);
+    const isDevUtilsEsbuild = isDevUtilsPreset(answers.preset) && answers.bundler === "esbuild";
+    const plugin = getBuildPlugin(answers.bundler);
+    if (plugin !== null && !isDevUtilsEsbuild) {
+      builder.addPackage(plugin);
+    }
+    builder.addPackage("svelte-check").addDepcheckIgnore(
+      "svelte-check",
+      isDevUtilsEsbuild ? "run as a CLI by obsidian-dev-utils' `build:compile`, which refuses to build without it declared." : "run as a CLI by `scripts/build.ts`."
+    );
+    if (!isDevUtilsEsbuild && SVELTE_PREPROCESS_BUNDLERS.has(answers.bundler)) {
+      builder.addPackage("svelte-preprocess");
+    }
+    if (answers.bundler === "webpack") {
+      builder.addDepcheckIgnore("svelte-loader", "named as a loader string in `scripts/webpack.config.ts`.");
+    }
+    if (answers.bundler === "parcel") {
+      builder.addFiles(["parcel-transformer-svelte.cjs"]);
+    }
+  }
+};
+function getBuildPlugin(bundler) {
+  if (!Object.hasOwn(BUILD_PLUGINS4, bundler)) {
+    throw new Error(`Unsupported bundler for Svelte: ${bundler}`);
+  }
+  return BUILD_PLUGINS4[bundler] ?? null;
+}
+
+// src/features/ui-framework/vue.ts
+var BUILD_PLUGINS5 = {
+  esbuild: "esbuild-plugin-vue3",
+  parcel: "@parcel/transformer-vue",
+  rollup: "rollup-plugin-vue",
+  vite: "@vitejs/plugin-vue",
+  webpack: "vue-loader"
+};
+var Vue = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Progressive framework with SFC", promptLabel: "Vue", settingValue: "vue" });
+  }
+  configure(builder, answers) {
+    builder.addPackage("vue").addPackage(getBuildPlugin2(answers.bundler)).addPartial("ui-view").addSentenceCaseBrand("Vue").addFiles([
+      "src/vue-components/sample-vue-component.d.ts",
+      "src/vue-components/sample-vue-component.vue",
+      "src/views/sample-vue-view.ts"
+    ]);
+    if (answers.bundler === "rollup") {
+      builder.addPackage("@babel/core").addPackage("@babel/preset-typescript").addPackage("@rollup/plugin-babel").addDepcheckIgnore("@babel/preset-typescript", "named as a string in `scripts/rollup.config.ts`, never imported.").addPartial("rollup-babel");
+    }
+    if (answers.bundler === "parcel") {
+      builder.addDepcheckIgnore("@parcel/transformer-vue", "resolved by name by `@parcel/config-default` for `.vue`; nothing imports it.");
+    }
+  }
+};
+function getBuildPlugin2(bundler) {
+  const plugin = BUILD_PLUGINS5[bundler];
+  if (!plugin) {
+    throw new Error(`Unsupported bundler for Vue: ${bundler}`);
+  }
+  return plugin;
+}
+
+// src/features/ui-framework/index.ts
+var UI_FRAMEWORK_OPTIONS = [new None16(), new Lit(), new Preact(), new React(), new Solid(), new Svelte(), new Vue()];
+async function promptUiFramework(savedValue) {
+  return promptFeature({ defaultOption: new None16(), message: "UI framework", options: UI_FRAMEWORK_OPTIONS, savedValue });
+}
+
+// src/features/wasm-support/none.ts
+var None17 = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "No WASM", promptLabel: "(none)", settingValue: "none" });
+  }
+};
+
+// src/features/wasm-support/wasm.ts
+var WASM_PLUGINS = {
+  esbuild: null,
+  parcel: null,
+  rollup: "@rollup/plugin-wasm",
+  vite: null,
+  webpack: null
+};
+var Wasm = class extends FeatureOption {
+  constructor() {
+    super({ promptHint: "Import and use .wasm modules", promptLabel: "WASM", settingValue: "wasm" });
+  }
+  configure(builder, answers) {
+    const plugin = getWasmPlugin(answers.bundler);
+    if (plugin !== null) {
+      builder.addPackage(plugin);
+    }
+    builder.addSentenceCaseBrand("WASM");
+    builder.addFiles([
+      // The one binary in the template tree, copied verbatim (see `ASSET_EXTENSIONS`). 39 bytes, one
+      // Export, `answer()`, returning 42 -- the sample module from CodeScript Toolkit's demo vault.
+      "src/wasm/module.wasm",
+      // Its source in WebAssembly text format. Documentation only: nothing in the build reads it, and it
+      // Is here so the binary beside it is not opaque.
+      "src/wasm/module.wat",
+      "src/wasm.d.ts",
+      "src/wasm/answer.ts",
+      "src/wasm/sample-command.ts",
+      "src/wasm/README.md"
+    ]);
+    if (isDevUtilsPreset(answers.preset)) {
+      builder.addFiles(["demo-vault/03 WebAssembly.md"]);
+    }
+  }
+};
+function getWasmPlugin(bundler) {
+  if (!Object.hasOwn(WASM_PLUGINS, bundler)) {
+    throw new Error(`Unsupported bundler for WASM: ${bundler}`);
+  }
+  return WASM_PLUGINS[bundler] ?? null;
+}
+
+// src/features/wasm-support/index.ts
+var WASM_SUPPORT_OPTIONS = [new None17(), new Wasm()];
+async function promptWasmSupport(savedValue) {
+  return promptFeature({ defaultOption: new None17(), message: "WebAssembly support", options: WASM_SUPPORT_OPTIONS, savedValue });
+}
+
+// src/answer-space.ts
+var SAMPLE_FUNDING_URL = "https://example.com/support-testuser";
+var SAMPLE_OBSIDIAN_CONFIG_FOLDER = "demo-vault/.obsidian";
+var ANSWER_SPACE = [
+  toDimension("apiSubset", API_SUBSET_OPTIONS),
+  toDimension("bundler", BUNDLER_OPTIONS),
+  toDimension("commitLinting", COMMIT_LINTING_OPTIONS),
+  toDimension("coverageBadge", COVERAGE_BADGE_OPTIONS),
+  toDimension("e2eTestRunner", E2E_TEST_RUNNER_OPTIONS),
+  toDimension("editorExtensions", EDITOR_EXTENSIONS_OPTIONS),
+  toDimension("formatter", FORMATTER_OPTIONS),
+  toDimension("fundingPlatform", FUNDING_PLATFORM_OPTIONS),
+  toValueDimension("fundingUrl", ["", SAMPLE_FUNDING_URL]),
+  toDimension("gitHubActions", GITHUB_ACTIONS_OPTIONS),
+  toDimension("gitHubIssueTemplates", GITHUB_ISSUE_TEMPLATES_OPTIONS),
+  toDimension("hotReload", HOT_RELOAD_OPTIONS),
+  toDimension("internationalization", INTERNATIONALIZATION_OPTIONS),
+  toDimension("linter", LINTER_OPTIONS),
+  toDimension("markdownLinter", MARKDOWN_LINTER_OPTIONS),
+  toValueDimension("obsidianConfigFolder", ["", SAMPLE_OBSIDIAN_CONFIG_FOLDER]),
+  toDimension("packageManager", PACKAGE_MANAGER_OPTIONS),
+  toDimension("platformSupport", PLATFORM_SUPPORT_OPTIONS),
+  toDimension("preset", PRESET_OPTIONS),
+  toDimension("spellChecker", SPELL_CHECKER_OPTIONS),
+  toDimension("styling", STYLING_OPTIONS),
+  toDimension("testRunner", TEST_RUNNER_OPTIONS),
+  toDimension("uiFramework", UI_FRAMEWORK_OPTIONS),
+  toDimension("wasmSupport", WASM_SUPPORT_OPTIONS)
+];
+var ANSWER_SPACE_SIZE = ANSWER_SPACE.reduce((size, dimension) => size * dimension.values.length, 1);
+var ANSWER_SPACE_DIMENSION_SIZES = ANSWER_SPACE.map((dimension) => dimension.values.length);
+function toDimension(answerKey, options) {
+  return {
+    answerKey,
+    values: options.map((option) => option.settingValue)
+  };
+}
+function toValueDimension(answerKey, values) {
+  return { answerKey, values };
+}
+
+// src/answers.ts
+var CONFIG_FILE_NAME = ".create-obsidian-plugin.json";
+function getPluginShortName(pluginId) {
+  return pluginId.split("-").map((word) => (word[0] ?? "").toUpperCase() + word.slice(1)).join("");
+}
+
+// src/directory-constraints.ts
+var CORE_FEATURE_NAMES = [
+  "Audio recorder",
+  "Backlinks",
+  "Bases",
+  "Bookmarks",
+  "Canvas",
+  "Command palette",
+  "Daily notes",
+  "File recovery",
+  "Files",
+  "Footnotes",
+  "Format converter",
+  "Graph view",
+  "Live Preview",
+  "Note composer",
+  "Outgoing links",
+  "Outline",
+  "Page preview",
+  "Properties view",
+  "Publish",
+  "Quick Switcher",
+  "Random note",
+  "Reading view",
+  "Search",
+  "Slash commands",
+  "Slides",
+  "Source mode",
+  "Sync",
+  "Tags view",
+  "Templates",
+  "Unique note creator",
+  "Web viewer",
+  "Word count",
+  "Workspaces"
+];
+var MAX_DESCRIPTION_LENGTH = 250;
+var MIN_DESCRIPTION_LENGTH = 10;
+var ALLOWED_ID_CHARACTERS = /^[a-z0-9-]+$/;
+var ALLOWED_NAME_CHARACTERS = /^[A-Za-z0-9 \-+()]+$/;
+var EMOJI = /\p{Extended_Pictographic}/u;
+var OBSIDIAN_WORD = /\bobsidian\b/i;
+var OBSIDIAN_NAME_VARIANTS = /obsi|sidian/i;
+var SELF_REFERENCE_PATTERNS = [
+  /\bthis plugin\b/i,
+  /\bthis is a plugin\b/i,
+  /\ba plugin (?:that|which)\b/i,
+  /^the plugin\b/i,
+  /^plugin\b/i
+];
+function findUnlistableManifestAnswers(answers) {
+  const checked = [
+    { key: "pluginId", message: validatePluginId(answers.pluginId), value: answers.pluginId },
+    { key: "pluginName", message: validatePluginName(answers.pluginName), value: answers.pluginName },
+    { key: "pluginDescription", message: validatePluginDescription(answers.pluginDescription), value: answers.pluginDescription }
+  ];
+  const problems = [];
+  for (const { key, message, value } of checked) {
+    if (message !== void 0) {
+      problems.push({ key, message, value });
+    }
+  }
+  return problems;
+}
+function validatePluginDescription(input) {
+  if (!input) {
+    return "Should not be empty";
+  }
+  if (EMOJI.test(input)) {
+    return "Should not contain emoji -- the Community directory rejects them, though it does accept ordinary punctuation such as backticks, em dashes and parentheses";
+  }
+  if (OBSIDIAN_WORD.test(input)) {
+    return 'Should not contain the word "Obsidian" -- the Community directory rejects it as implied by the plugin directory, even though no Obsidian document says so';
+  }
+  if (SELF_REFERENCE_PATTERNS.some((pattern) => pattern.test(input))) {
+    return 'Should say what the plugin does rather than refer to itself -- the Community directory rejects "This plugin..." and "a plugin that...". Naming another plugin is fine';
+  }
+  if (input.length < MIN_DESCRIPTION_LENGTH) {
+    return `Should be at least ${String(MIN_DESCRIPTION_LENGTH)} characters, so it says what the plugin does`;
+  }
+  if (input.length > MAX_DESCRIPTION_LENGTH) {
+    return `Should be at most ${String(MAX_DESCRIPTION_LENGTH)} characters -- the Community directory rejects a longer one`;
+  }
+  if (!/^[A-Z]/.test(input)) {
+    return 'Should start with a capital letter, ideally on an action verb: "Translates selected text...", "Imports notes from..."';
+  }
+  if (!input.endsWith(".")) {
+    return "Should end with a dot";
+  }
+  return void 0;
+}
+function validatePluginId(input) {
+  if (!input) {
+    return "Should not be empty";
+  }
+  if (!ALLOWED_ID_CHARACTERS.test(input)) {
+    return "Should contain only lowercase English letters, digits and hyphens";
+  }
+  if (!/^[a-z]/.test(input)) {
+    return "Should start with a letter";
+  }
+  if (!/[a-z0-9]$/.test(input)) {
+    return "Should end with a letter or digit";
+  }
+  if (input.includes("obsidian")) {
+    return 'Should not contain "obsidian" anywhere -- the Community directory rejects it as implied by the plugin directory, and an id can never be changed once the plugin is published';
+  }
+  if (input.endsWith("plugin")) {
+    return 'Should not end with "plugin" -- the Community directory rejects it as implied, and an id can never be changed once the plugin is published';
+  }
+  return void 0;
+}
+function validatePluginName(input) {
+  if (!input) {
+    return "Should not be empty";
+  }
+  if (OBSIDIAN_NAME_VARIANTS.test(input)) {
+    return 'Should not contain "Obsidian" or an abbreviation of it ("Obsi", "sidian") -- the Community directory rejects it as implied by the plugin directory';
+  }
+  if (input.toLowerCase().includes("plugin")) {
+    return 'Should not contain "Plugin" -- the Community directory rejects it as implied by the plugin directory';
+  }
+  const coreName = findCoreFeatureName(input);
+  if (coreName !== void 0) {
+    return `Should not be the name of an Obsidian core plugin or core feature -- "${coreName}" is one, and the Community directory rejects a name that takes it`;
+  }
+  if (!ALLOWED_NAME_CHARACTERS.test(input)) {
+    return "Should use Basic Latin letters and digits only, with hyphens, plus signs and parentheses the only punctuation the Community directory accepts";
+  }
+  return void 0;
+}
+function findCoreFeatureName(name) {
+  const normalized = name.trim().toLowerCase();
+  return CORE_FEATURE_NAMES.find((candidate) => candidate.toLowerCase() === normalized);
+}
+
+// src/prompts.ts
+import {
+  cancel as cancel2,
+  log
+} from "@clack/prompts";
+import { styleText as styleText3 } from "node:util";
+
+// src/clack-text.ts
+import {
+  settings as settings2,
+  TextPrompt
+} from "@clack/core";
+import {
+  S_BAR as S_BAR2,
+  S_BAR_END as S_BAR_END2,
+  symbol as symbol2
+} from "@clack/prompts";
+import { styleText as styleText2 } from "node:util";
+var TextPromptWithCompletion = class extends TextPrompt {
+  completionValue;
+  constructor(opts) {
+    super(opts);
+    this.completionValue = opts.defaultValue ?? opts.placeholder ?? "";
+  }
+  _isActionKey(char, key) {
+    if (this.shouldComplete(key)) {
+      this._clearUserInput();
+      this._setUserInput(this.completionValue, true);
+      return false;
+    }
+    return super._isActionKey(char, key);
+  }
+  shouldComplete(key) {
+    if (this.userInput || !this.completionValue) {
+      return false;
+    }
+    return key.name === "tab" || key.name === "right" || key.name === "end";
+  }
+};
+async function text(opts) {
+  const textOpts = {
+    render() {
+      const withGuide = settings2.withGuide;
+      const header = `${withGuide ? `${styleText2("gray", S_BAR2)}
+` : ""}${symbol2(this.state)}  ${opts.message}
+`;
+      const placeholderDisplay = opts.placeholder ? styleText2("inverse", opts.placeholder[0] ?? "") + styleText2("dim", opts.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_");
+      const input = this.userInput ? this.userInputWithCursor : placeholderDisplay;
+      const val = this.value ?? "";
+      switch (this.state) {
+        case "cancel": {
+          const strikeVal = val ? `  ${styleText2(["strikethrough", "dim"], val)}` : "";
+          const bar = withGuide ? styleText2("gray", S_BAR2) : "";
+          return `${header}${bar}${strikeVal}${val.trim() ? `
+${bar}` : ""}`;
+        }
+        case "error": {
+          const errorMsg = this.error ? `  ${styleText2("yellow", this.error)}` : "";
+          const bar = withGuide ? `${styleText2("yellow", S_BAR2)}  ` : "";
+          const barEnd = withGuide ? styleText2("yellow", S_BAR_END2) : "";
+          return `${header.trim()}
+${bar}${input}
+${barEnd}${errorMsg}
+`;
+        }
+        case "submit": {
+          const dimVal = val ? `  ${styleText2("dim", val)}` : "";
+          const bar = withGuide ? styleText2("gray", S_BAR2) : "";
+          return `${header}${bar}${dimVal}`;
+        }
+        default: {
+          const bar = withGuide ? `${styleText2("cyan", S_BAR2)}  ` : "";
+          const barEnd = withGuide ? styleText2("cyan", S_BAR_END2) : "";
+          return `${header}${bar}${input}
+${barEnd}
+`;
+        }
+      }
+    },
+    validate: opts.validate
+  };
+  if (opts.defaultValue !== void 0) {
+    textOpts.defaultValue = opts.defaultValue;
+  }
+  if (opts.placeholder !== void 0) {
+    textOpts.placeholder = opts.placeholder;
+  }
+  const prompt = new TextPromptWithCompletion(textOpts);
+  prompt.on("key", (_char, key) => {
+    if (key.name === "escape") {
+      setEscapeCancel();
+    }
+  });
+  resetCancelFlag();
+  const result = await prompt.prompt();
+  return throwGoBackOnCancel(result) ?? "";
+}
+
+// src/prompts.ts
+var DEFAULT_PLUGIN_ID = "my-awesome-helper";
+function getDefaultAnswers(defaults) {
+  const pluginId = defaults?.pluginId ?? DEFAULT_PLUGIN_ID;
+  const base = getDefaultAnswersBase(pluginId);
+  if (!defaults) {
+    return base;
+  }
+  const overrides = { fundingUsername: defaults.authorGitHubName ?? base.fundingUsername };
+  for (const [key, value] of Object.entries(defaults)) {
+    if (value !== void 0) {
+      overrides[key] = value;
+    }
+  }
+  return { ...base, ...overrides };
+}
+function makePluginName(pluginId) {
+  return extractWords(pluginId).join(" ");
+}
+async function promptAnswers(defaults) {
+  showHotkeyHints();
+  const defaultTooling = getDefaultTooling();
+  const steps = skipSuppliedAnswers(buildPromptSteps(defaults ?? {}, defaultTooling), defaults ?? {});
+  const answers = await runPromptSteps(steps);
+  return buildAnswers(answers, defaultTooling);
+}
+function validateNotEmpty(value) {
+  if (!value) {
+    return "Should not be empty";
+  }
+  return void 0;
+}
+function buildAnswers(answers, defaultTooling) {
+  function get(key, fallback) {
+    return answers.get(key) ?? fallback;
+  }
+  const pluginId = get("pluginId", DEFAULT_PLUGIN_ID);
+  return {
+    apiSubset: get("apiSubset", defaultTooling.apiSubset),
+    authorGitHubName: get("authorGitHubName", "johndoe"),
+    authorName: get("authorName", "John Doe"),
+    bundler: get("bundler", "esbuild"),
+    commitLinting: get("commitLinting", defaultTooling.commitLinting),
+    coverageBadge: get("coverageBadge", defaultTooling.coverageBadge),
+    currentYear: (/* @__PURE__ */ new Date()).getFullYear(),
+    defaultBranch: get("defaultBranch", "main"),
+    e2eTestRunner: get("e2eTestRunner", defaultTooling.e2eTestRunner),
+    editorExtensions: get("editorExtensions", defaultTooling.editorExtensions),
+    formatter: get("formatter", defaultTooling.formatter),
+    fundingPlatform: get("fundingPlatform", "buy-me-a-coffee"),
+    fundingUrl: get("fundingUrl", ""),
+    fundingUsername: get("fundingUsername", get("authorGitHubName", "johndoe")),
+    gitHubActions: get("gitHubActions", defaultTooling.gitHubActions),
+    gitHubIssueTemplates: get("gitHubIssueTemplates", defaultTooling.gitHubIssueTemplates),
+    hotReload: get("hotReload", defaultTooling.hotReload),
+    internationalization: get("internationalization", defaultTooling.internationalization),
+    linter: get("linter", defaultTooling.linter),
+    markdownLinter: get("markdownLinter", defaultTooling.markdownLinter),
+    obsidianConfigFolder: get("obsidianConfigFolder", ""),
+    packageManager: get("packageManager", "npm"),
+    platformSupport: get("platformSupport", "desktop-only"),
+    pluginDescription: get("pluginDescription", "Does something awesome."),
+    pluginId,
+    pluginName: get("pluginName", makePluginName(pluginId)),
+    preset: get("preset", "enhanced"),
+    spellChecker: get("spellChecker", defaultTooling.spellChecker),
+    styling: get("styling", defaultTooling.styling),
+    testRunner: get("testRunner", defaultTooling.testRunner),
+    uiFramework: get("uiFramework", "none"),
+    wasmSupport: get("wasmSupport", defaultTooling.wasmSupport)
+  };
+}
+function buildPromptSteps(d, defaultTooling) {
+  function isCustomize(answers) {
+    return answers.get("toolingMode") === "customize";
+  }
+  function skipUnlessCustomize(answers) {
+    return !isCustomize(answers);
+  }
+  return [
+    {
+      defaultValue: () => d.preset ?? "enhanced",
+      key: "preset",
+      prompt: (saved) => promptPreset(saved)
+    },
+    {
+      defaultValue: () => "defaults",
+      key: "toolingMode",
+      prompt: () => promptToolingMode(),
+      skip: (answers) => answers.get("preset") === "demo"
+    },
+    {
+      defaultValue: (answers) => answers.get("preset") === "demo" ? "esbuild" : d.bundler ?? "esbuild",
+      key: "bundler",
+      prompt: (saved) => promptBundler(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: (answers) => answers.get("preset") === "demo" ? "none" : d.uiFramework ?? "none",
+      key: "uiFramework",
+      prompt: (saved) => promptUiFramework(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.linter ?? defaultTooling.linter,
+      key: "linter",
+      prompt: (saved) => promptLinter(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.formatter ?? defaultTooling.formatter,
+      key: "formatter",
+      prompt: (saved) => promptFormatter(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.spellChecker ?? defaultTooling.spellChecker,
+      key: "spellChecker",
+      prompt: (saved) => promptSpellChecker(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.markdownLinter ?? defaultTooling.markdownLinter,
+      key: "markdownLinter",
+      prompt: (saved) => promptMarkdownLinter(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.testRunner ?? defaultTooling.testRunner,
+      key: "testRunner",
+      prompt: (saved) => promptTestRunner(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.e2eTestRunner ?? defaultTooling.e2eTestRunner,
+      key: "e2eTestRunner",
+      prompt: (saved) => promptE2eTestRunner(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.editorExtensions ?? defaultTooling.editorExtensions,
+      key: "editorExtensions",
+      prompt: (saved) => promptEditorExtensions(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.styling ?? defaultTooling.styling,
+      key: "styling",
+      prompt: (saved) => promptStyling(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.wasmSupport ?? defaultTooling.wasmSupport,
+      key: "wasmSupport",
+      prompt: (saved) => promptWasmSupport(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.commitLinting ?? defaultTooling.commitLinting,
+      key: "commitLinting",
+      prompt: (saved) => promptCommitLinting(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.hotReload ?? defaultTooling.hotReload,
+      key: "hotReload",
+      prompt: (saved) => promptHotReload(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.internationalization ?? defaultTooling.internationalization,
+      key: "internationalization",
+      prompt: (saved) => promptInternationalization(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.gitHubActions ?? defaultTooling.gitHubActions,
+      key: "gitHubActions",
+      prompt: (saved) => promptGitHubActions(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.gitHubIssueTemplates ?? defaultTooling.gitHubIssueTemplates,
+      key: "gitHubIssueTemplates",
+      prompt: (saved) => promptGitHubIssueTemplates(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.coverageBadge ?? defaultTooling.coverageBadge,
+      key: "coverageBadge",
+      prompt: (saved) => promptCoverageBadge(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.apiSubset ?? defaultTooling.apiSubset,
+      key: "apiSubset",
+      prompt: (saved) => promptApiSubset(saved),
+      skip: (answers) => !(isCustomize(answers) && answers.get("preset") === "enhanced")
+    },
+    {
+      defaultValue: () => d.packageManager ?? "npm",
+      key: "packageManager",
+      prompt: (saved) => promptPackageManager(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.platformSupport ?? "desktop-only",
+      key: "platformSupport",
+      prompt: (saved) => promptPlatformSupport(saved),
+      skip: skipUnlessCustomize
+    },
+    {
+      defaultValue: () => d.pluginId ?? "",
+      key: "pluginId",
+      prompt: (saved) => text({
+        defaultValue: saved || void 0,
+        message: "Plugin id (lowercase, hyphens allowed)",
+        placeholder: saved || DEFAULT_PLUGIN_ID,
+        validate: validatePluginId
+      })
+    },
+    {
+      defaultValue: (answers) => d.pluginName ?? makePluginName(answers.get("pluginId") ?? DEFAULT_PLUGIN_ID),
+      key: "pluginName",
+      prompt: (saved) => promptPluginName(saved)
+    },
+    {
+      defaultValue: () => d.pluginDescription ?? "Does something awesome.",
+      key: "pluginDescription",
+      prompt: (saved) => promptPluginDescription(saved)
+    },
+    {
+      defaultValue: () => d.authorName ?? "John Doe",
+      key: "authorName",
+      prompt: (saved) => text({
+        defaultValue: saved,
+        message: "Your full name",
+        placeholder: saved,
+        validate: validateNotEmpty
+      })
+    },
+    {
+      defaultValue: () => d.authorGitHubName ?? "johndoe",
+      key: "authorGitHubName",
+      prompt: (saved) => text({
+        defaultValue: saved,
+        message: "Your GitHub username",
+        placeholder: saved,
+        validate: validateNotEmpty
+      })
+    },
+    {
+      defaultValue: () => d.defaultBranch ?? "main",
+      key: "defaultBranch",
+      prompt: (saved) => text({
+        defaultValue: saved,
+        message: "Default branch name. `git init` creates it, and the CI workflow triggers on it.",
+        placeholder: saved,
+        validate: validateNotEmpty
+      })
+    },
+    // Asked outside Customize: it is a fact about the author, not a tooling choice, and choosing `none`
+    // Here is the only way the recommended-defaults path has to opt out of funding altogether.
+    {
+      defaultValue: () => d.fundingPlatform ?? "buy-me-a-coffee",
+      key: "fundingPlatform",
+      prompt: (saved) => promptFundingPlatform(saved)
+    },
+    {
+      defaultValue: (answers) => d.fundingUsername ?? answers.get("authorGitHubName") ?? "johndoe",
+      key: "fundingUsername",
+      prompt: (saved) => text({
+        defaultValue: saved,
+        message: "Your username on that funding platform",
+        placeholder: saved,
+        validate: validateFundingUsername
+      }),
+      skip: (answers) => !asksFundingUsername(answers.get("fundingPlatform"))
+    },
+    {
+      defaultValue: () => d.fundingUrl ?? "",
+      key: "fundingUrl",
+      prompt: (saved) => text({
+        defaultValue: saved || void 0,
+        message: "Funding URL",
+        placeholder: saved || "https://example.com/support-me",
+        validate: validateNotEmpty
+      }),
+      skip: (answers) => answers.get("fundingPlatform") !== "custom"
+    },
+    {
+      defaultValue: () => d.obsidianConfigFolder ?? "",
+      key: "obsidianConfigFolder",
+      prompt: (saved) => text({
+        defaultValue: saved || void 0,
+        message: "Path to test vault config folder (.obsidian, by default, but it is configurable in Obsidian settings). This enables auto-update of your plugin in your test vault during dev. Leave empty if you prefer to update the plugin manually.",
+        placeholder: saved || "path/to/test-vault/.obsidian"
+      })
+    }
+  ];
+}
+function extractWords(pluginId) {
+  return pluginId.split("-").map((w) => (w[0] ?? "").toUpperCase() + w.slice(1));
+}
+function getDefaultAnswersBase(pluginId) {
+  return {
+    ...getDefaultTooling(),
+    authorGitHubName: "johndoe",
+    authorName: "John Doe",
+    bundler: "esbuild",
+    currentYear: (/* @__PURE__ */ new Date()).getFullYear(),
+    defaultBranch: "main",
+    fundingPlatform: "buy-me-a-coffee",
+    fundingUrl: "",
+    fundingUsername: "johndoe",
+    obsidianConfigFolder: "",
+    packageManager: "npm",
+    platformSupport: "desktop-only",
+    pluginDescription: "Does something awesome.",
+    pluginId,
+    pluginName: makePluginName(pluginId),
+    preset: "enhanced",
+    uiFramework: "none"
+  };
+}
+function getDefaultTooling() {
+  return {
+    apiSubset: "official",
+    commitLinting: "conventional-commits",
+    coverageBadge: "none",
+    e2eTestRunner: "none",
+    editorExtensions: "none",
+    formatter: "dprint",
+    gitHubActions: "ci-and-release",
+    gitHubIssueTemplates: "bug-and-feature",
+    hotReload: "obsidian-cli",
+    internationalization: "none",
+    linter: "eslint",
+    markdownLinter: "markdownlint",
+    spellChecker: "cspell",
+    styling: "scss",
+    testRunner: "vitest",
+    wasmSupport: "none"
+  };
+}
+function promptPluginDescription(saved) {
+  const value = saved || void 0;
+  return text({
+    defaultValue: value,
+    message: "Plugin description",
+    placeholder: value ?? "Does something awesome.",
+    validate: validatePluginDescription
+  });
+}
+function promptPluginName(saved) {
+  const value = saved || void 0;
+  return text({
+    defaultValue: value,
+    message: "Plugin display name",
+    placeholder: value ?? makePluginName(DEFAULT_PLUGIN_ID),
+    validate: validatePluginName
+  });
+}
+async function promptToolingMode() {
+  return select({
+    initialValue: "defaults",
+    message: "Tooling",
+    options: [
+      { hint: "Choose each tool individually", label: "Customize", value: "customize" },
+      { hint: "ESLint, dprint, SCSS, Vitest, and more", label: "Use recommended defaults", value: "defaults" }
+    ]
+  });
+}
+async function runPromptSteps(steps) {
+  const answers = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < steps.length) {
+    const step = steps[i];
+    if (step.skip?.(answers)) {
+      answers.set(step.key, step.defaultValue(answers));
+      i++;
+      continue;
+    }
+    try {
+      const savedValue = answers.get(step.key) ?? step.defaultValue(answers);
+      answers.set(step.key, await step.prompt(savedValue));
+      i++;
+    } catch (error) {
+      if (!(error instanceof GoBackError)) {
+        throw error;
+      }
+      answers.delete(step.key);
+      i--;
+      while (i > 0 && steps[i]?.skip?.(answers)) {
+        const skippedStep = steps[i];
+        answers.delete(skippedStep.key);
+        i--;
+      }
+      if (i < 0) {
+        cancel2("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  return answers;
+}
+function showHotkeyHints() {
+  function dim(s) {
+    return styleText3("dim", s);
+  }
+  function key(s) {
+    return styleText3("cyan", s);
+  }
+  log.info([
+    `${key("\u2191\u2193")} Navigate  ${key("Enter")} Confirm  ${key("Esc")} Go back`,
+    `${dim("Text inputs:")} ${key("Tab")}/${key("\u2192")}/${key("End")} Accept suggestion`
+  ].join("\n"));
+}
+function skipSuppliedAnswers(steps, supplied) {
+  return steps.map((step) => ({
+    ...step,
+    skip: (answers) => supplied[step.key] !== void 0 || (step.skip?.(answers) ?? false)
+  }));
+}
+
+// src/cli-args.ts
+var COMPUTED_ANSWER_KEYS = ["currentYear"];
+var DERIVED_TEMPLATE_KEYS = ["pluginShortName"];
+var REFUSED_KEYS = [...COMPUTED_ANSWER_KEYS, ...DERIVED_TEMPLATE_KEYS];
+var ANSWERS_FILE_PREFIX = "--answersFile=";
+var CUSTOM_TEMPLATE_PREFIX = "--customTemplate=";
+var MODE_PREFIX = "--mode=";
+var MODES = ["create" /* Create */, "update" /* Update */];
+var FLAG_PREFIX_LENGTH = 2;
+var FREE_TEXT_VALIDATORS = {
+  authorGitHubName: validateNotEmpty,
+  authorName: validateNotEmpty,
+  defaultBranch: validateNotEmpty,
+  fundingUsername: validateFundingUsername,
+  pluginDescription: validatePluginDescription,
+  pluginId: validatePluginId,
+  pluginName: validatePluginName
+};
+var DEMO_PINNED_ANSWER_KEYS = ["bundler", "uiFramework"];
+function assertValidAnswer(key, value) {
+  const dimension = findChoiceDimension(key);
+  if (dimension) {
+    if (!dimension.values.includes(value)) {
+      throw new Error(`"${value}" is not an answer to ${key}. It accepts: ${dimension.values.join(", ")}.`);
+    }
+    return;
+  }
+  const message = FREE_TEXT_VALIDATORS[key]?.(value);
+  if (message !== void 0) {
+    throw new Error(`"${value}" is not a valid ${key}. ${message}.`);
+  }
+}
+function getAnswerableKeys() {
+  return Object.keys(getDefaultAnswers()).filter((key) => !COMPUTED_ANSWER_KEYS.includes(key)).sort();
+}
+function getHelpText() {
+  const lines = [
+    "Usage: npm create @mnaoumov/obsidian-plugin [-- <options>]",
+    "",
+    "Options:",
+    "  -y, --yes                 Take every default and skip the post-scaffold prompts. Never asks:",
+    "                            a question no flag answers stops the run and names the flag.",
+    "  -h, --help                Show this help.",
+    `      --mode=${MODES.join("|")}  Create a new plugin, or update the project in the current`,
+    "                            directory, without being asked which.",
+    "      --force               Scaffold into an obsidian-<pluginId> directory that already exists.",
+    "      --answersFile=<path>  Read answers from a JSON file. Accepts a bare answers object or a",
+    "                            `.create-obsidian-plugin.json`. Individual flags override it.",
+    "      --customTemplate=<dir> Layer your own templates over the built-in ones: a directory",
+    "                            mirroring templates/default, plus an overlay.json. Recorded in the",
+    "                            project and re-applied on update; pass it empty to drop it.",
+    "",
+    "Answers (any of these may be given as --<key>=<value>):"
+  ];
+  for (const key of getAnswerableKeys()) {
+    const dimension = findChoiceDimension(key);
+    lines.push(dimension ? `  --${key}=${dimension.values.join("|")}` : `  --${key}=<text>`);
+  }
+  return lines.join("\n");
+}
+function parseCliArgs(argv) {
+  const flagAnswers = {};
+  let answersFilePath = null;
+  let customTemplate;
+  let force = false;
+  let mode;
+  let showHelp = false;
+  let useDefaults = false;
+  for (const argument of argv) {
+    if (argument === "--yes" || argument === "-y") {
+      useDefaults = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      showHelp = true;
+      continue;
+    }
+    if (argument.startsWith(ANSWERS_FILE_PREFIX)) {
+      answersFilePath = argument.slice(ANSWERS_FILE_PREFIX.length);
+      continue;
+    }
+    if (argument.startsWith(CUSTOM_TEMPLATE_PREFIX)) {
+      customTemplate = argument.slice(CUSTOM_TEMPLATE_PREFIX.length);
+      continue;
+    }
+    if (argument === "--force") {
+      force = true;
+      continue;
+    }
+    if (argument.startsWith(MODE_PREFIX)) {
+      mode = toMode(argument.slice(MODE_PREFIX.length));
+      continue;
+    }
+    const [rawKey, value] = splitFlag(argument);
+    const key = toAnswerKey(rawKey);
+    assertValidAnswer(key, value);
+    flagAnswers[key] = value;
+  }
+  const fileAnswers = answersFilePath === null ? {} : readAnswersFile(answersFilePath);
+  const answers = { ...fileAnswers, ...flagAnswers };
+  assertNoDemoConflict(answers);
+  return {
+    answers,
+    customTemplate,
+    force,
+    mode,
+    showHelp,
+    useDefaults
+  };
+}
+function toAnswerKey(key) {
+  if (REFUSED_KEYS.includes(key)) {
+    throw new Error(`${key} is computed by the generator, not answered, so it cannot be set.`);
+  }
+  const answerable = getAnswerableKeys();
+  if (!answerable.includes(key)) {
+    throw new Error(`Unknown answer "${key}". The answers are: ${answerable.join(", ")}.`);
+  }
+  return key;
+}
+function assertNoDemoConflict(answers) {
+  if (answers.preset !== "demo") {
+    return;
+  }
+  for (const key of DEMO_PINNED_ANSWER_KEYS) {
+    if (answers[key] !== void 0) {
+      throw new Error(`preset=demo pins ${key}, so the two cannot be given together. Drop --${key}, or choose another preset.`);
+    }
+  }
+}
+function findChoiceDimension(key) {
+  const dimension = ANSWER_SPACE.find((candidate) => candidate.answerKey === key);
+  if (!dimension || dimension.values.includes("")) {
+    return null;
+  }
+  return dimension;
+}
+function readAnswersFile(path) {
+  if (!existsSync(path)) {
+    throw new Error(`Answers file not found: ${path}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    throw new Error(`Answers file is not valid JSON: ${path}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Answers file should contain a JSON object: ${path}`);
+  }
+  const record = parsed;
+  const wrapped = record["answers"];
+  const source = typeof wrapped === "object" && wrapped !== null ? wrapped : record;
+  const answers = {};
+  for (const [rawKey, value] of Object.entries(source)) {
+    if (REFUSED_KEYS.includes(rawKey)) {
+      continue;
+    }
+    if (typeof value !== "string") {
+      throw new Error(`${rawKey} in ${path} should be a string, got ${typeof value}.`);
+    }
+    const key = toAnswerKey(rawKey);
+    assertValidAnswer(key, value);
+    answers[key] = value;
+  }
+  return answers;
+}
+function splitFlag(argument) {
+  if (!argument.startsWith("--")) {
+    throw new Error(`Expected --<answer>=<value>, got "${argument}".`);
+  }
+  const separatorIndex = argument.indexOf("=");
+  if (separatorIndex === -1) {
+    throw new Error(`Expected --<answer>=<value>, got "${argument}".`);
+  }
+  return [argument.slice(FLAG_PREFIX_LENGTH, separatorIndex), argument.slice(separatorIndex + 1)];
+}
+function toMode(value) {
+  if (!MODES.includes(value)) {
+    throw new Error(`"${value}" is not a mode. It accepts: ${MODES.join(", ")}.`);
+  }
+  return value;
+}
+
+// src/answers-export.ts
+var CREATE_COMMANDS = {
+  bun: { prefix: "bun create @mnaoumov/obsidian-plugin", separator: "" },
+  npm: { prefix: "npm create @mnaoumov/obsidian-plugin", separator: " --" },
+  pnpm: { prefix: "pnpm create @mnaoumov/obsidian-plugin", separator: "" },
+  yarn: { prefix: "yarn create @mnaoumov/obsidian-plugin", separator: "" }
+};
+var JSON_INDENT_SPACES = 2;
+function formatAnswersJson(answers) {
+  const exported = {};
+  for (const key of getExportableKeys(answers)) {
+    exported[key] = String(answers[key]);
+  }
+  return `${JSON.stringify(exported, null, JSON_INDENT_SPACES)}
+`;
+}
+function formatCreateCommand(answers, shell, customTemplate) {
+  const create = CREATE_COMMANDS[answers.packageManager] ?? CREATE_COMMANDS["npm"];
+  const head = `${create?.prefix ?? ""}${create?.separator ?? ""} --yes --mode=create`;
+  const flags = getExportableKeys(answers).map((key) => `--${key}=${quote(String(answers[key]), shell)}`);
+  if (customTemplate) {
+    flags.push(`--customTemplate=${quote(customTemplate, shell)}`);
+  }
+  if (shell === "cmd") {
+    return [head, ...flags].join(" ");
+  }
+  return [head, ...flags].join(" \\\n  ");
+}
+function formatCreateScript(answers, shell, customTemplate) {
+  const command = formatCreateCommand(answers, shell, customTemplate);
+  if (shell === "cmd") {
+    return ["@echo off", command, ""].join("\r\n");
+  }
+  return ["#!/usr/bin/env sh", "set -e", "", command, ""].join("\n");
+}
+function getExportableKeys(answers) {
+  const keys = getAnswerableKeys();
+  if (answers.preset !== "demo") {
+    return keys;
+  }
+  return keys.filter((key) => !DEMO_PINNED_ANSWER_KEYS.includes(key));
+}
+function getScriptExtension(shell) {
+  return shell === "cmd" ? ".cmd" : ".sh";
+}
+function getShellForPlatform(platform) {
+  return platform === "win32" ? "cmd" : "sh";
+}
+function quote(value, shell) {
+  if (shell === "cmd") {
+    return `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  }
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/directory-registry.ts
+var COMMUNITY_PLUGINS_JSON_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/community-plugins.json";
+async function fetchCommunityPluginIds() {
+  try {
+    const response = await fetch(COMMUNITY_PLUGINS_JSON_URL);
+    if (!response.ok) {
+      return null;
+    }
+    return parseCommunityPluginIds(await response.json());
+  } catch {
+    return null;
+  }
+}
+function makeUnlistedPluginIdValidator(listedIds) {
+  return (input) => validatePluginId(input) ?? validatePluginIdIsUnlisted(input ?? "", listedIds);
+}
+function parseCommunityPluginIds(json) {
+  if (!Array.isArray(json)) {
+    return null;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of json) {
+    if (typeof entry.id === "string") {
+      ids.add(entry.id.toLowerCase());
+    }
+  }
+  return ids.size === 0 ? null : ids;
+}
+function validatePluginIdIsUnlisted(pluginId, listedIds) {
+  if (!listedIds.has(pluginId.toLowerCase())) {
+    return void 0;
+  }
+  return `"${pluginId}" is already the id of a plugin in the Community directory -- the directory requires every id to be unique, and an id can never be changed once the plugin is published`;
+}
+
+// src/overlay.ts
+import {
+  existsSync as existsSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  statSync as statSync2
+} from "node:fs";
+import {
+  isAbsolute,
+  join as join3,
+  relative,
+  resolve
+} from "node:path";
+
+// src/plan-checks.ts
+import {
+  existsSync as existsSync3,
+  readdirSync,
+  readFileSync as readFileSync3,
+  statSync
+} from "node:fs";
+import {
+  extname as extname2,
+  join as join2
+} from "node:path";
+
+// src/templates.ts
+import { log as log3 } from "@clack/prompts";
+import ejs from "ejs";
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync
+} from "node:fs";
+import {
+  dirname,
+  extname,
+  join
+} from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/template-builder.ts
+var PARTIAL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var Dependency = class {
+  packageName;
+  /**
+   * The spec to write into `package.json`, or `null` to let it be resolved -- from the pin table if the
+   * package is pinned, otherwise from the registry. Set one only when the package must carry that exact
+   * spec regardless of what either would produce.
+   */
+  version;
+  constructor(packageName, version = null) {
+    this.packageName = packageName;
+    this.version = version;
+  }
+};
+var TemplateBuilder = class {
+  get badges() {
+    return [...this._badges];
+  }
+  get depcheckIgnores() {
+    return [...this._depcheckIgnores.entries()].map(([packageName, reason]) => ({ packageName, reason })).sort((a, b) => a.packageName.localeCompare(b.packageName));
+  }
+  get dependencies() {
+    return [...this._dependencies.values()].sort((a, b) => a.packageName.localeCompare(b.packageName));
+  }
+  get lintStagedPatterns() {
+    return [...this._lintStagedPatterns.entries()].map(([pattern, commands]) => ({ commands: [...commands], pattern }));
+  }
+  get partials() {
+    return new Set(this._partials);
+  }
+  get scripts() {
+    return Object.fromEntries(Object.entries(this._scripts).sort(([a], [b]) => a.localeCompare(b)));
+  }
+  get sentenceCaseBrands() {
+    return [...this._sentenceCaseBrands].sort((a, b) => a.localeCompare(b));
+  }
+  get templateFiles() {
+    return new Set(this._templateFiles);
+  }
+  _badges = [];
+  _depcheckIgnores = /* @__PURE__ */ new Map();
+  _dependencies = /* @__PURE__ */ new Map();
+  _lintStagedPatterns = /* @__PURE__ */ new Map();
+  _partials = /* @__PURE__ */ new Set();
+  _scripts = {};
+  _sentenceCaseBrands = /* @__PURE__ */ new Set();
+  _templateFiles = /* @__PURE__ */ new Set();
+  /**
+   * Registers a README badge, rendered in registration order on the line under the title.
+   *
+   * Collected here rather than composed from a `render('badges')` seam because the badges have to stay on
+   * ONE source line: Obsidian renders markdown with `breaks: true`, and each partial would end in the
+   * newline that turns into a `<br>` between two badges.
+   */
+  addBadge(markdown) {
+    this._badges.push(markdown);
+    return this;
+  }
+  /**
+   * Registers a declared package that depcheck reports as unused although it is not -- one only ever
+   * invoked as a CLI, named as a string in a config, or reached by a compiler option.
+   *
+   * Called beside the `addPackage` that declares it, so an ignore exists exactly when its package does.
+   * Collected here rather than concatenated from template partials for the same reason as
+   * {@link addLintStagedCommand}: a partial can only emit `'<name>',`, and the last trailing comma is
+   * invalid JSON. The reason is kept because the emitted file records one per entry: once the file
+   * exists, a dependency sweep treats anything depcheck still reports as a failure, so an entry without
+   * its reason is a false positive nobody can re-verify.
+   */
+  addDepcheckIgnore(packageName, reason) {
+    this._depcheckIgnores.set(packageName, reason);
+    return this;
+  }
+  addFiles(paths) {
+    for (const p of paths) {
+      this._templateFiles.add(p);
+    }
+    return this;
+  }
+  /**
+   * Registers a `.lintstagedrc` command.
+   *
+   * The commands are collected here rather than concatenated from template partials because a partial can
+   * only ever emit `'<command>',` -- and the trailing comma the last one leaves behind is exactly what the
+   * generated formatter config strips, so the file failed its own `format:check`.
+   */
+  addLintStagedCommand(pattern, command) {
+    const commands = this._lintStagedPatterns.get(pattern) ?? [];
+    commands.push(command);
+    this._lintStagedPatterns.set(pattern, commands);
+    return this;
+  }
+  addPackage(packageName, version) {
+    this._dependencies.set(packageName, new Dependency(packageName, version));
+    return this;
+  }
+  addPartial(name) {
+    if (!PARTIAL_NAME_PATTERN.test(name)) {
+      throw new Error(`Partial name "${name}" is not kebab-case, so its template files would not be recognized as partials.`);
+    }
+    this._partials.add(name);
+    return this;
+  }
+  addScript(name, command) {
+    if (!command) {
+      const scriptName = name.replaceAll(":", "-");
+      command = `jiti scripts/${scriptName}.ts`;
+    }
+    this._scripts[name] = command;
+    return this;
+  }
+  /**
+   * Registers a proper noun that `obsidianmd/ui/sentence-case` must not flag.
+   *
+   * Collected here rather than concatenated from template partials for the same reason as
+   * {@link addLintStagedCommand}: a partial can only emit `'<brand>',`, and the last trailing comma is
+   * what the generated formatter config strips.
+   */
+  addSentenceCaseBrand(brand) {
+    this._sentenceCaseBrands.add(brand);
+    return this;
+  }
+};
+
+// src/versions.ts
+import { log as log2 } from "@clack/prompts";
+var PINNED_VERSIONS = {
+  "@babel/core": {
+    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    checkRequires: "@rollup/plugin-babel",
+    expect: "^7.0.0",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^7.29.7",
+    why: "@babel/core is only ever added alongside @rollup/plugin-babel, whose newest release still peers on `^7.0.0` while the registry tags 8.x as latest. Resolving latest therefore produced an `npm install` that fails outright with ERESOLVE for rollup with preact, react or solid. The check reads the peer range @rollup/plugin-babel itself declares, so the pin retires itself when that widens to ^8."
+  },
+  "@babel/plugin-transform-react-jsx": {
+    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    checkRequires: "@rollup/plugin-babel",
+    expect: "^7.0.0",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^7.29.7",
+    why: "Held on 7.x for the same reason as @babel/core, and it has to move as one set: 8.0.1 peers on `@babel/core@^8.0.0`, so pinning core to 7 without pinning this one just moves the ERESOLVE. Only ever added for rollup + preact, which is exactly where @rollup/plugin-babel forces 7."
+  },
+  "@babel/preset-react": {
+    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    checkRequires: "@rollup/plugin-babel",
+    expect: "^7.0.0",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^7.29.7",
+    why: "Held on 7.x for the same reason as @babel/core, and it has to move as one set: 8.0.1 peers on `@babel/core@^8.0.0`. Only ever added for rollup + react, which is exactly where @rollup/plugin-babel forces 7."
+  },
+  "@babel/preset-typescript": {
+    check: `node -e "process.stdout.write(require('@rollup/plugin-babel/package.json').peerDependencies['@babel/core'])"`,
+    checkRequires: "@rollup/plugin-babel",
+    expect: "^7.0.0",
+    manualCheck: null,
+    needsOverride: false,
+    section: "devDependencies",
+    version: "^7.29.7",
+    why: "Held on 7.x for the same reason as @babel/core, and it has to move as one set: 8.0.1 peers on `@babel/core@^8.0.0`. Only ever added for rollup + vue, which is exactly where @rollup/plugin-babel forces 7."
+  },
+  "@codemirror/language": {
+    check: null,
+    checkRequires: null,
+    expect: null,
+    manualCheck: "Must be the @codemirror/language release built against the @codemirror/state version Obsidian peers on. Bump it only together with @codemirror/state.",
+    needsOverride: false,
+    section: "devDependencies",
+    version: "6.12.4",
+    why: "Obsidian bundles its own CodeMirror. A @codemirror/language built against a different @codemirror/state duplicates the state package at runtime, and two copies of a CodeMirror facet do not interoperate."
+  },
+  "@codemirror/state": {
+    check: `node -e "process.stdout.write(require('obsidian/package.json').peerDependencies['@codemirror/state'])"`,
+    checkRequires: "obsidian",
+    expect: "6.5.0",
+    manualCheck: null,
+    needsOverride: true,
+    section: "devDependencies",
+    version: "6.5.0",
+    why: "obsidian peers on this exact version. Anything else fails npm install with ERESOLVE, and a second copy in the tree breaks editor extensions at runtime."
+  },
+  "@codemirror/view": {
+    check: `node -e "process.stdout.write(require('obsidian/package.json').peerDependencies['@codemirror/view'])"`,
+    checkRequires: "obsidian",
+    expect: "6.38.6",
+    manualCheck: null,
+    needsOverride: true,
+    section: "devDependencies",
+    version: "6.38.6",
+    why: "obsidian peers on this exact version. Anything else fails npm install with ERESOLVE, and a second copy in the tree breaks editor extensions at runtime."
+  },
+  "moment": {
+    check: null,
+    checkRequires: null,
+    expect: null,
+    manualCheck: "Must stay on the version Obsidian bundles, so the plugin and the app share one moment instance. Check Obsidian's bundled moment before changing it.",
+    needsOverride: false,
+    section: "devDependencies",
+    version: "2.29.4",
+    why: "Obsidian bundles moment 2.29.4 and re-exports it. Type-checking against a newer moment describes an API the running app does not have."
+  },
+  "typescript": {
+    check: `node -e "process.stdout.write(require('typescript-eslint/package.json').peerDependencies.typescript)"`,
+    checkRequires: "typescript-eslint",
+    expect: ">=4.8.4 <6.1.0",
+    manualCheck: "TypeScript 7 (tsgo) is a native rewrite much of this toolchain has not migrated to. Re-check that every type-aware tool in the project supports 7 before lifting the pin.",
+    needsOverride: true,
+    section: "devDependencies",
+    version: "6.0.3",
+    why: "TypeScript 7 (tsgo) breaks this toolchain: typescript-eslint's parser crashes on the native API, so type-aware ESLint cannot run on 7. typescript-eslint peer-requires the range below, so 6.x is the last usable major."
+  }
+};
+var ADVISORY_OVERRIDES = {
+  "@puppeteer/browsers": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@wdio/utils/package.json','utf8')).dependencies['@puppeteer/browsers'])"`,
+    expect: "^2.2.0",
+    manualCheck: "The check reads @wdio/utils's own declared range, not a version, because that range is what makes the override necessary. When it moves to ^3 or later, @wdio/utils no longer pulls extract-zip in and both this override and this entry can go.",
+    requires: ["obsidian-dev-utils", "wdio-obsidian-service"],
+    spec: "^3.2.1",
+    why: "Clears GHSA-jmr9-qjv8-65gv (extract-zip unvalidated symlink path traversal). extract-zip is vulnerable at every published version, so there is nothing to override it to, and the direct dependency cannot be bumped either: even the newest webdriverio reaches extract-zip through @wdio/utils -> @puppeteer/browsers ^2.x. @puppeteer/browsers@3 replaced extract-zip with modern-tar, so forcing 3.x on @wdio/utils, the only consumer left on 2.x, removes the subtree. @wdio/utils imports only install, canDownload, resolveBuildId, detectBrowserPlatform, Browser, ChromeReleaseChannel, computeExecutablePath and the InstallOptions type, all still exported by 3.x, and both packages are ESM-only. Never take the `npm audit fix --force` remedy: it downgrades obsidian-integration-testing to 1.1.2."
+  },
+  "deepmerge-ts": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/@wdio/utils/package.json','utf8')).dependencies['deepmerge-ts'])"`,
+    expect: "^7.0.3",
+    manualCheck: "The check reads the range @wdio/utils declares, which is what forces the override. When it moves to ^8 or later the override and this entry can go. Before lifting it, re-run the deepmergeCustom probe: @wdio/config passes a `mergeArrays` handler that reads `meta.key`, and that is the API 8.0.0 renamed.",
+    requires: ["obsidian-dev-utils", "wdio-obsidian-service"],
+    spec: "^8.0.2",
+    why: "Clears GHSA-ggr8-5vv4-36mx (stack exhaustion merging recursive object graphs), patched in 8.0.0. Every wdio package still declares ^7.0.3, including the newest, so no direct bump reaches it and `npm audit fix --force` only offers a downgrade of obsidian-integration-testing to 1.1.2. The forced major is safe for these consumers: 8.0.0 breaks by renaming the mergeInfo system and aligning the customization shorthand, and both surfaces were measured to behave identically on 7.1.6 and 8.0.1 in the exact shapes the tree uses -- @wdio/config's `deepmergeCustom` with a `mergeArrays` handler reading `meta.key` and returning `utils.actions.defaultMerge`, and webdriver's `deepmergeCustom({ mergeArrays: false })`. A scan of the whole installed tree found no other binding than `deepmerge` and `deepmergeCustom`."
+  },
+  "serialize-javascript": {
+    check: `node -e "const fs=require('node:fs');process.stdout.write(JSON.parse(fs.readFileSync('node_modules/mocha/package.json','utf8')).dependencies['serialize-javascript'])"`,
+    expect: "^6.0.2",
+    manualCheck: "The check reads mocha's own declared range, not a version, because that range is what makes the override necessary. When mocha moves to ^7 or later the override and this entry can go.",
+    requires: ["@wdio/mocha-framework"],
+    spec: "^7.1.1",
+    why: "Clears GHSA-5c6j-r48x-rmvq (RCE via RegExp.flags and Date.prototype.toISOString) and GHSA-qj8w-gfj5-8c6v (CPU-exhaustion denial of service via crafted array-likes), both fixed in 7.0.5. No direct bump reaches it: mocha declares `serialize-javascript@^6.0.2` at every published version including 11.8.0, and the only consumer here is @wdio/mocha-framework -> mocha. `npm audit fix --force` offers a DOWNGRADE to @wdio/mocha-framework@7.7.3 instead. The forced major is safe for the one call site that exists: mocha's `buffered-worker-pool.js` calls `serializeJavascript(opts, { unsafe: true, ignoreFunction: true })`, and 6.0.2 and 7.1.1 were measured to return byte-identical output for that exact option pair across RegExp, Date, Map, Set, undefined, BigInt, functions and a script-tag string. Note the call is on mocha's parallel-run path, which wdio does not take."
+  }
+};
+var DESKTOP_RELEASES_JSON_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json";
+var FALLBACK_MIN_APP_VERSION = "1.13.0";
+var FALLBACK_VERSION = "latest";
+var JSON_INDENT_SPACES2 = 2;
+var REGISTRY_URL = "https://registry.npmjs.org";
+function buildOverrides(dependencies) {
+  const overrides = {};
+  for (const packageName of getPinnedPackageNames(dependencies)) {
+    if (PINNED_VERSIONS[packageName]?.needsOverride) {
+      overrides[packageName] = `$${packageName}`;
+    }
+  }
+  for (const [packageName, advisoryOverride] of getAdvisoryOverrides(dependencies)) {
+    overrides[packageName] = advisoryOverride.spec;
+  }
+  return overrides;
+}
+function buildPinnedVersionsJson(dependencies) {
+  const pins = {};
+  for (const packageName of getPinnedPackageNames(dependencies)) {
+    const pin = PINNED_VERSIONS[packageName];
+    if (!pin) {
+      continue;
+    }
+    const canCheck = pin.check !== null && (pin.checkRequires === null || hasPackage(dependencies, pin.checkRequires));
+    pins[packageName] = canCheck ? {
+      check: pin.check,
+      expect: pin.expect,
+      section: pin.section,
+      why: pin.why
+    } : {
+      check: null,
+      manualCheck: pin.manualCheck ?? pin.why,
+      section: pin.section,
+      why: pin.why
+    };
+  }
+  for (const [packageName, advisoryOverride] of getAdvisoryOverrides(dependencies)) {
+    pins[packageName] = {
+      check: advisoryOverride.check,
+      expect: advisoryOverride.expect,
+      manualCheck: advisoryOverride.manualCheck,
+      section: "overrides",
+      why: advisoryOverride.why
+    };
+  }
+  const content = {
+    comment: [
+      "Release conditions for every exact-pinned version in package.json (dependencies, devDependencies and",
+      "overrides), plus every override added to clear an npm audit advisory reached only transitively.",
+      "An exact pin is invisible to a caret-range dependency sweep, so nothing would ever remind you",
+      "that a pin is stale. This file is what makes that check happen: run each `check` and compare its trimmed",
+      "stdout to `expect`. Equal means the pin is still required; different means the condition that justified it",
+      "has changed and the pin should be re-examined. `check: null` means no mechanical test exists - follow",
+      "`manualCheck` instead. Every exact pin belongs here, and every entry must name a package that is actually",
+      "present in the declared section."
+    ],
+    pins
+  };
+  return `${JSON.stringify(content, null, JSON_INDENT_SPACES2)}
+`;
+}
+function buildResolutions(dependencies) {
+  const resolutions = {};
+  for (const [packageName, spec] of Object.entries(buildOverrides(dependencies))) {
+    resolutions[packageName] = spec.startsWith("$") ? PINNED_VERSIONS[spec.slice(1)]?.version ?? spec : spec;
+  }
+  return resolutions;
+}
+async function fetchLatestObsidianVersion() {
+  try {
+    const response = await fetch(DESKTOP_RELEASES_JSON_URL);
+    if (!response.ok) {
+      return FALLBACK_MIN_APP_VERSION;
+    }
+    const desktopReleasesJson = await response.json();
+    return desktopReleasesJson.latestVersion ?? FALLBACK_MIN_APP_VERSION;
+  } catch {
+    return FALLBACK_MIN_APP_VERSION;
+  }
+}
+async function fetchLatestVersion(packageName) {
+  try {
+    const response = await fetch(`${REGISTRY_URL}/${packageName}/latest`);
+    if (!response.ok) {
+      return null;
+    }
+    const packument = await response.json();
+    return packument.version;
+  } catch {
+    return null;
+  }
+}
+async function resolveVersions(dependencies) {
+  const resolved = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  for (const dependency of dependencies) {
+    if (dependency.version !== null) {
+      resolved.set(dependency.packageName, dependency.version);
+      continue;
+    }
+    const pin = PINNED_VERSIONS[dependency.packageName];
+    if (pin) {
+      resolved.set(dependency.packageName, pin.version);
+      continue;
+    }
+    unresolved.push(dependency.packageName);
+  }
+  const fetched = await Promise.all(unresolved.map(fetchLatestVersion));
+  const failed = [];
+  for (const [index, version] of fetched.entries()) {
+    const packageName = unresolved[index] ?? "";
+    if (version === null) {
+      failed.push(packageName);
+      resolved.set(packageName, FALLBACK_VERSION);
+      continue;
+    }
+    resolved.set(packageName, `^${version}`);
+  }
+  if (failed.length > 0) {
+    log2.warn(`Could not look up the latest version of ${failed.join(", ")}. Falling back to "${FALLBACK_VERSION}".`);
+  }
+  return resolved;
+}
+function getAdvisoryOverrides(dependencies) {
+  return Object.entries(ADVISORY_OVERRIDES).filter(([, advisoryOverride]) => advisoryOverride.requires.some((packageName) => hasPackage(dependencies, packageName))).sort(([a], [b]) => a.localeCompare(b));
+}
+function getPinnedPackageNames(dependencies) {
+  return dependencies.map((dependency) => dependency.packageName).filter((packageName) => packageName in PINNED_VERSIONS).sort((a, b) => a.localeCompare(b));
+}
+function hasPackage(dependencies, packageName) {
+  return dependencies.some((dependency) => dependency.packageName === packageName);
+}
+
+// src/templates.ts
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([".wasm"]);
+var JSON_INDENT_SPACES3 = 2;
+var UNRESOLVED_VERSION = "latest";
+var BASE_TEMPLATE_FILES = [
+  // Never empty: `tslib` and `typescript` below are false positives on every answer set.
+  ".depcheckrc.json",
+  ".editorconfig",
+  ".env",
+  ".gitattributes",
+  ".gitignore",
+  ".npmrc",
+  "CONTRIBUTING.md",
+  "LICENSE",
+  "README.md",
+  "manifest.json",
+  "package.json",
+  "pinned-versions.json",
+  // Emitted for every project, not only the pnpm answer, for the same reason `resolutions` is: which
+  // Tool installs a checkout is not a property of the checkout. Without it `pnpm install` FAILS with
+  // ERR_PNPM_IGNORED_BUILDS -- pnpm blocks dependency install scripts by default and, since 10, treats
+  // That as an error rather than a warning.
+  "pnpm-workspace.yaml",
+  "src/main.ts",
+  "src/plugin.ts",
+  "tsconfig.json",
+  "versions.json"
+];
+var FEATURE_REGISTRIES = [
+  { answerKey: "preset", options: PRESET_OPTIONS },
+  { answerKey: "bundler", options: BUNDLER_OPTIONS },
+  { answerKey: "uiFramework", options: UI_FRAMEWORK_OPTIONS },
+  { answerKey: "linter", options: LINTER_OPTIONS },
+  { answerKey: "formatter", options: FORMATTER_OPTIONS },
+  { answerKey: "spellChecker", options: SPELL_CHECKER_OPTIONS },
+  { answerKey: "markdownLinter", options: MARKDOWN_LINTER_OPTIONS },
+  { answerKey: "testRunner", options: TEST_RUNNER_OPTIONS },
+  { answerKey: "e2eTestRunner", options: E2E_TEST_RUNNER_OPTIONS },
+  { answerKey: "editorExtensions", options: EDITOR_EXTENSIONS_OPTIONS },
+  { answerKey: "styling", options: STYLING_OPTIONS },
+  { answerKey: "commitLinting", options: COMMIT_LINTING_OPTIONS },
+  { answerKey: "hotReload", options: HOT_RELOAD_OPTIONS },
+  { answerKey: "internationalization", options: INTERNATIONALIZATION_OPTIONS },
+  { answerKey: "gitHubActions", options: GITHUB_ACTIONS_OPTIONS },
+  { answerKey: "gitHubIssueTemplates", options: GITHUB_ISSUE_TEMPLATES_OPTIONS },
+  { answerKey: "fundingPlatform", options: FUNDING_PLATFORM_OPTIONS },
+  { answerKey: "coverageBadge", options: COVERAGE_BADGE_OPTIONS },
+  { answerKey: "wasmSupport", options: WASM_SUPPORT_OPTIONS },
+  { answerKey: "apiSubset", options: API_SUBSET_OPTIONS },
+  // Both of these were missing, and a question absent from this list is a question the user is asked
+  // And whose answer is then discarded. `platformSupport` was the live one: `manifest.json.ejs` calls
+  // `render('platform')` and both partials sit on disk, but with nothing contributing `desktop-only` or
+  // `desktop-and-mobile` the section rendered as nothing, so EVERY generated manifest shipped without
+  // `isDesktopOnly` -- a required field. `packageManager` contributes no partial today and so changes
+  // No output; it is registered anyway, because "every question is here" is the invariant that keeps
+  // The next one from going the same way, and because a `X_npm.ejs` added later should just work.
+  { answerKey: "platformSupport", options: PLATFORM_SUPPORT_OPTIONS },
+  { answerKey: "packageManager", options: PACKAGE_MANAGER_OPTIONS }
+];
+var DEMO_OVERRIDES = [
+  { answerKey: "uiFramework", demoValue: "react", options: UI_FRAMEWORK_OPTIONS },
+  { answerKey: "uiFramework", demoValue: "svelte", options: UI_FRAMEWORK_OPTIONS },
+  { answerKey: "uiFramework", demoValue: "vue", options: UI_FRAMEWORK_OPTIONS },
+  { answerKey: "editorExtensions", demoValue: "codemirror", options: EDITOR_EXTENSIONS_OPTIONS },
+  { answerKey: "linter", demoValue: "eslint", exclusive: true, options: LINTER_OPTIONS },
+  { answerKey: "markdownLinter", demoValue: "markdownlint", options: MARKDOWN_LINTER_OPTIONS },
+  { answerKey: "spellChecker", demoValue: "cspell", options: SPELL_CHECKER_OPTIONS },
+  { answerKey: "styling", demoValue: "scss", options: STYLING_OPTIONS }
+];
+function buildTemplate(answers, overlay = null) {
+  const builder = new TemplateBuilder();
+  builder.addFiles(BASE_TEMPLATE_FILES).addPackage("@types/node").addPackage("jiti").addPackage("obsidian").addPackage("tslib").addDepcheckIgnore("tslib", "never imported by name: `importHelpers: true` in `tsconfig.json` makes the compiled output import it.").addPackage("typescript").addDepcheckIgnore("typescript", "the compiler `tsconfig.json` configures, reached by `tsc`, by the TypeScript step of the bundler and by the editor rather than by an import.").addSentenceCaseBrand(answers.pluginName).addPartial("common");
+  const funding = resolveFunding(answers);
+  if (funding) {
+    builder.addFiles([".github/FUNDING.yml"]).addBadge(funding.getBadge(answers)).addPartial("has-funding");
+  }
+  const repoUrl = `https://github.com/${answers.authorGitHubName}/obsidian-${answers.pluginId}`;
+  builder.addBadge(`[![GitHub release](https://img.shields.io/github/v/release/${answers.authorGitHubName}/obsidian-${answers.pluginId})](${repoUrl}/releases)`).addBadge(`[![GitHub downloads](https://img.shields.io/github/downloads/${answers.authorGitHubName}/obsidian-${answers.pluginId}/total)](${repoUrl}/releases)`);
+  if (answers.obsidianConfigFolder) {
+    builder.addPartial("has-vault-true");
+  } else {
+    builder.addPartial("has-vault-false");
+  }
+  for (const registry of FEATURE_REGISTRIES) {
+    const value = String(answers[registry.answerKey]);
+    const option = resolveFeature(registry.options, value);
+    option.configure(builder, answers);
+    builder.addPartial(option.partialName);
+  }
+  if (answers.preset === "demo") {
+    for (const override of DEMO_OVERRIDES) {
+      const chosenValue = String(answers[override.answerKey]);
+      if (chosenValue === override.demoValue || override.exclusive && chosenValue !== "none") {
+        continue;
+      }
+      const option = resolveFeature(override.options, override.demoValue);
+      if (conflictsOverJsxRuntime(resolveFeature(override.options, chosenValue), option)) {
+        continue;
+      }
+      option.configure(builder, answers);
+      builder.addPartial(option.partialName);
+    }
+  }
+  if (overlay) {
+    applyOverlay(builder, overlay);
+  }
+  if (builder.lintStagedPatterns.length > 0) {
+    addStagedFilesHook(builder);
+  }
+  return builder;
+}
+function copyTemplates(answers, targetDir, currentVersion, existingConfig, resolvedVersions = /* @__PURE__ */ new Map(), minAppVersion = FALLBACK_MIN_APP_VERSION, overlay = null, projectFormatter) {
+  const templatesDir = join(getScriptDir(), "..", "templates", "default");
+  function findTemplate(relativePath) {
+    if (overlay) {
+      const overlayPath = join(overlay.dir, relativePath);
+      if (existsSync2(overlayPath)) {
+        return overlayPath;
+      }
+    }
+    const builtInPath = join(templatesDir, relativePath);
+    return existsSync2(builtInPath) ? builtInPath : null;
+  }
+  const newConfig = {
+    fileHashes: {},
+    generatorVersion: currentVersion
+  };
+  const builder = buildTemplate(answers, overlay);
+  const templateFiles = builder.templateFiles;
+  const partials = builder.partials;
+  const dependencies = builder.dependencies;
+  let currentTemplatePath = "";
+  let renderRoot = "";
+  const templateContext = {
+    ...answers,
+    ...getFundingTemplateContext(answers),
+    _badges: builder.badges,
+    _depcheckIgnores: builder.depcheckIgnores,
+    _dependencies: dependencies.map((dependency) => ({
+      packageName: dependency.packageName,
+      version: dependency.version ?? resolvedVersions.get(dependency.packageName) ?? PINNED_VERSIONS[dependency.packageName]?.version ?? UNRESOLVED_VERSION
+    })),
+    _lintStagedPatterns: builder.lintStagedPatterns,
+    _minAppVersion: minAppVersion,
+    _overrides: Object.entries(buildOverrides(dependencies)).map(([packageName, spec]) => ({ packageName, spec })),
+    _ownRepoLinkPattern: getOwnRepoLinkPattern(answers),
+    _pinnedVersionsJson: buildPinnedVersionsJson(dependencies),
+    _resolutions: Object.entries(buildResolutions(dependencies)).map(([packageName, spec]) => ({ packageName, spec })),
+    _scripts: builder.scripts,
+    _sentenceCaseBrands: builder.sentenceCaseBrands,
+    pluginShortName: getPluginShortName(answers.pluginId),
+    render(options) {
+      const { indentLevel, section } = typeof options === "string" ? { indentLevel: 0, section: options } : { indentLevel: 0, section: void 0, ...options };
+      const basePath = (renderRoot || currentTemplatePath).replace(/\.ejs$/, "");
+      const previousTemplatePath = currentTemplatePath;
+      const previousRenderRoot = renderRoot;
+      let result = "";
+      for (const partial of partials) {
+        const partialPath = section ? `${basePath}@${section}_${partial}.ejs` : `${basePath}_${partial}.ejs`;
+        const fullPath = findTemplate(partialPath);
+        if (fullPath === null) {
+          continue;
+        }
+        currentTemplatePath = partialPath;
+        renderRoot = previousRenderRoot || partialPath;
+        let rendered = ejs.render(readFileSync2(fullPath, "utf-8"), templateContext);
+        if (indentLevel > 0) {
+          const indent = "  ".repeat(indentLevel);
+          rendered = rendered.replaceAll(/^(?<Content>.+)$/gm, `${indent}$<Content>`);
+        }
+        result += rendered;
+      }
+      currentTemplatePath = previousTemplatePath;
+      renderRoot = previousRenderRoot;
+      return result;
+    },
+    /**
+     * Sorts a block of `import` statements a template composed from partials, by the module each names.
+     *
+     * A section that contributes imports emits them in PARTIAL order, which is the order the answers were
+     * registered in {@link FEATURE_REGISTRIES} -- and that has nothing to do with the order an
+     * import-sorting lint rule wants. The obsidian-dev-utils presets now adopt that package's shared
+     * ESLint config, which sorts imports as an ERROR, so `uiFramework=lit editorExtensions=codemirror`
+     * emitted a `src/plugin.ts` that was red the moment it was generated. The sorting cannot be pushed
+     * into the partials: each one knows only itself, and which others are beside it is the answer set.
+     */
+    sortImports(text3) {
+      return sortImportStatements(text3);
+    }
+  };
+  const skipped = [];
+  const updated = [];
+  const created = [];
+  const written = [];
+  for (const registeredPath of templateFiles) {
+    const destinationPath = getDestinationPath(registeredPath, answers);
+    const fullDestinationPath = join(targetDir, destinationPath);
+    const isAsset = ASSET_EXTENSIONS.has(extname(registeredPath));
+    const ejsPath = findTemplate(`${registeredPath}.ejs`);
+    let rendered;
+    if (isAsset) {
+      currentTemplatePath = registeredPath;
+      rendered = readFileSync2(findTemplate(registeredPath) ?? join(templatesDir, registeredPath));
+    } else if (ejsPath === null) {
+      currentTemplatePath = `${registeredPath}.ejs`;
+      rendered = templateContext["render"]();
+    } else {
+      currentTemplatePath = `${registeredPath}.ejs`;
+      try {
+        rendered = ejs.render(readFileSync2(ejsPath, "utf-8"), templateContext);
+      } catch (error) {
+        if (overlay && ejsPath.startsWith(overlay.dir)) {
+          throw new Error(`${ejsPath} failed to render: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+        rendered = readFileSync2(ejsPath, "utf-8");
+      }
+    }
+    const newHash = sha256(rendered);
+    if (existingConfig && existsSync2(fullDestinationPath)) {
+      const currentContent = isAsset ? readFileSync2(fullDestinationPath) : readFileSync2(fullDestinationPath, "utf-8");
+      const currentHash = sha256(currentContent);
+      const originalHash = existingConfig.fileHashes[destinationPath];
+      if (matchesRender(currentHash, newHash, projectFormatter, destinationPath, rendered)) {
+        newConfig.fileHashes[destinationPath] = currentHash;
+        continue;
+      }
+      if (originalHash === void 0) {
+        skipped.push(destinationPath);
+        continue;
+      }
+      if (currentHash !== originalHash) {
+        skipped.push(destinationPath);
+        newConfig.fileHashes[destinationPath] = originalHash;
+        continue;
+      }
+      updated.push(destinationPath);
+    } else {
+      created.push(destinationPath);
+    }
+    newConfig.fileHashes[destinationPath] = newHash;
+    const destDir = dirname(fullDestinationPath);
+    if (!existsSync2(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+    writeFileSync(fullDestinationPath, rendered);
+    written.push(destinationPath);
+  }
+  formatWrittenFiles(projectFormatter, targetDir, written, newConfig);
+  const configPath = join(targetDir, CONFIG_FILE_NAME);
+  writeFileSync(configPath, `${JSON.stringify(newConfig, null, JSON_INDENT_SPACES3)}
+`);
+  if (existingConfig) {
+    logUpdateSummary(updated, created, skipped);
+  }
+  return newConfig;
+}
+function getDestinationPath(templatePath, answers) {
+  return templatePath.replace(/%= (?<AnswerKey>.+?) %/g, (_match, ...args) => String(answers[String(args[0])]));
+}
+function getScriptDir() {
+  return dirname(fileURLToPath(import.meta.url));
+}
+function isPartialTemplatePath(templatePath) {
+  const fileName = (templatePath.split("/").pop() ?? "").replace(/\.ejs$/, "");
+  const markerIndex = fileName.lastIndexOf("_");
+  return markerIndex > 0 && PARTIAL_NAME_PATTERN.test(fileName.slice(markerIndex + 1));
+}
+function loadConfig(dir) {
+  const configPath = join(dir, CONFIG_FILE_NAME);
+  if (!existsSync2(configPath)) {
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync2(configPath, "utf-8"));
+  const raw = parsed;
+  migrateAnswers(raw);
+  return parsed;
+}
+function recordHashesOnDisk(targetDir, config) {
+  const fileHashes = {};
+  for (const [destinationPath, hash] of Object.entries(config.fileHashes)) {
+    const fullPath = join(targetDir, destinationPath);
+    fileHashes[destinationPath] = existsSync2(fullPath) ? sha256(readFileSync2(fullPath)) : hash;
+  }
+  return { ...config, fileHashes };
+}
+function sortImportStatements(text3) {
+  const blocks = [];
+  let pendingComments = [];
+  for (const line of text3.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    if (line.startsWith("import ")) {
+      blocks.push([...pendingComments, line]);
+      pendingComments = [];
+    } else if (line.startsWith("//")) {
+      pendingComments.push(line);
+    } else {
+      blocks.at(-1)?.push(line);
+    }
+  }
+  if (blocks.length === 0) {
+    return text3;
+  }
+  blocks.at(-1)?.push(...pendingComments);
+  const statements = blocks.map((block) => block.join("\n"));
+  statements.sort((a, b) => importedModule(a).localeCompare(importedModule(b)));
+  return `${statements.join("\n")}
+`;
+}
+function applyOverlay(builder, overlay) {
+  builder.addFiles([...overlay.files]);
+  for (const packageName of overlay.packages) {
+    builder.addPackage(packageName);
+  }
+  for (const badge of overlay.badges) {
+    builder.addBadge(badge);
+  }
+  for (const partial of overlay.partials) {
+    builder.addPartial(partial);
+  }
+}
+function conflictsOverJsxRuntime(chosen, demo) {
+  return chosen.jsxImportSource !== void 0 && demo.jsxImportSource !== void 0 && chosen.jsxImportSource !== demo.jsxImportSource;
+}
+function formatWrittenFiles(projectFormatter, targetDir, written, config) {
+  const textFiles = written.filter((destinationPath) => !ASSET_EXTENSIONS.has(extname(destinationPath)));
+  if (!projectFormatter || textFiles.length === 0) {
+    return;
+  }
+  projectFormatter.formatFiles(textFiles);
+  for (const destinationPath of textFiles) {
+    config.fileHashes[destinationPath] = sha256(readFileSync2(join(targetDir, destinationPath)));
+  }
+}
+function getFundingTemplateContext(answers) {
+  const funding = resolveFunding(answers);
+  return {
+    _fundingYmlKey: funding?.fundingYmlKey ?? "",
+    _fundingYmlValue: funding?.getFundingYmlValue(answers) ?? "",
+    fundingUrl: funding?.getUrl(answers) ?? ""
+  };
+}
+function getOwnRepoLinkPattern(answers) {
+  const repoUrl = `https://github.com/${answers.authorGitHubName}/obsidian-${answers.pluginId}`;
+  return `^${repoUrl.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`)}(?:[/.?#]|$)`;
+}
+function importedModule(block) {
+  return /(?:from )?'(?<Module>[^']+)';$/.exec(block)?.groups?.["Module"] ?? block;
+}
+function logUpdateSummary(updated, created, skipped) {
+  if (updated.length > 0) {
+    log3.success(`Updated ${String(updated.length)} file(s):`);
+    for (const f of updated) {
+      log3.info(`  ${f}`);
+    }
+  }
+  if (created.length > 0) {
+    log3.success(`Created ${String(created.length)} new file(s):`);
+    for (const f of created) {
+      log3.info(`  ${f}`);
+    }
+  }
+  if (skipped.length > 0) {
+    log3.warn(`Skipped ${String(skipped.length)} file(s) with local modifications:`);
+    for (const f of skipped) {
+      log3.info(`  ${f}`);
+    }
+  }
+  if (updated.length === 0 && created.length === 0) {
+    log3.info("Everything is already up to date.");
+  }
+}
+function matchesRender(currentHash, newHash, projectFormatter, destinationPath, rendered) {
+  if (currentHash === newHash) {
+    return true;
+  }
+  if (!projectFormatter || typeof rendered !== "string") {
+    return false;
+  }
+  const formatted = projectFormatter.formatContent(destinationPath, rendered);
+  return formatted !== null && sha256(formatted) === currentHash;
+}
+function migrateAnswers(raw) {
+  const answers = raw["answers"];
+  if (!answers) {
+    return;
+  }
+  if (answers["framework"] && !answers["uiFramework"]) {
+    answers["uiFramework"] = answers["framework"];
+    delete answers["framework"];
+  }
+  if (answers["cssMode"] && !answers["styling"]) {
+    answers["styling"] = answers["cssMode"];
+    delete answers["cssMode"];
+  }
+  if (answers["buildSystem"] && !answers["bundler"]) {
+    answers["bundler"] = answers["buildSystem"];
+    delete answers["buildSystem"];
+  }
+  answers["defaultBranch"] ??= "master";
+  migrateFundingAnswers(answers);
+  answers["fundingUsername"] ??= answers["authorGitHubName"];
+  answers["coverageBadge"] ??= "none";
+  delete answers["pluginShortName"];
+}
+function migrateFundingAnswers(answers) {
+  if (answers["fundingPlatform"] !== void 0) {
+    return;
+  }
+  delete answers["gitHubFunding"];
+  const url = typeof answers["fundingUrl"] === "string" ? answers["fundingUrl"] : "";
+  if (!url) {
+    answers["fundingPlatform"] = "none";
+    answers["fundingUrl"] = "";
+    return;
+  }
+  function stripWww(value) {
+    return value.replace("://www.", "://");
+  }
+  for (const option of FUNDING_PLATFORM_OPTIONS) {
+    const prefix = stripWww(option.getUrl({ fundingUrl: "", fundingUsername: "" }));
+    const normalizedUrl = stripWww(url);
+    if (!prefix || !normalizedUrl.startsWith(prefix)) {
+      continue;
+    }
+    const handle = normalizedUrl.slice(prefix.length).replace(/\/$/, "");
+    if (!validateFundingUsername(handle)) {
+      answers["fundingPlatform"] = option.settingValue;
+      answers["fundingUsername"] = handle;
+      answers["fundingUrl"] = "";
+      return;
+    }
+  }
+  answers["fundingPlatform"] = "custom";
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/plan-checks.ts
+var EJS_SUFFIX = ".ejs";
+var RENDER_SITE_PATTERN = /(?:<%[-=]?|\$\{)\s*render\(\s*(?:'(?<Section>[^']*)'|\{(?<Options>[^}]*)\})/g;
+var SECTION_OPTION_PATTERN = /section\s*:\s*'(?<Section>[^']*)'/;
+function collectRenderSections(templateBody) {
+  const sections = [];
+  for (const match of templateBody.matchAll(RENDER_SITE_PATTERN)) {
+    const direct = match.groups?.["Section"];
+    if (direct !== void 0) {
+      sections.push(direct);
+      continue;
+    }
+    const fromOptions = SECTION_OPTION_PATTERN.exec(match.groups?.["Options"] ?? "")?.groups?.["Section"];
+    if (fromOptions !== void 0) {
+      sections.push(fromOptions);
+    }
+  }
+  return sections;
+}
+function loadTemplateInventory(templatesDir = defaultTemplatesDir()) {
+  const assetTemplates = /* @__PURE__ */ new Set();
+  const directTemplates = /* @__PURE__ */ new Set();
+  const emptyTemplates = /* @__PURE__ */ new Set();
+  const partials = [];
+  const renderSites = [];
+  for (const relativePath of walkTemplates(templatesDir, "")) {
+    if (ASSET_EXTENSIONS.has(extname2(relativePath))) {
+      assetTemplates.add(relativePath);
+      continue;
+    }
+    if (!relativePath.endsWith(EJS_SUFFIX)) {
+      continue;
+    }
+    const withoutSuffix = relativePath.slice(0, -EJS_SUFFIX.length);
+    const body = readFileSync3(join2(templatesDir, relativePath), "utf-8");
+    if (isPartialTemplatePath(relativePath)) {
+      partials.push(parsePartialPath(relativePath));
+    } else {
+      directTemplates.add(withoutSuffix);
+      if (body.trim() === "") {
+        emptyTemplates.add(withoutSuffix);
+      }
+    }
+    for (const section of collectRenderSections(body)) {
+      renderSites.push({ basePath: getRenderBase(withoutSuffix), section });
+    }
+  }
+  const wholeFilePartialsByBase = /* @__PURE__ */ new Map();
+  for (const partial of partials) {
+    if (partial.section !== null) {
+      continue;
+    }
+    const names = wholeFilePartialsByBase.get(partial.basePath) ?? [];
+    names.push(partial.partialName);
+    wholeFilePartialsByBase.set(partial.basePath, names);
+  }
+  return {
+    assetTemplates,
+    directTemplates,
+    emptyTemplates,
+    partials,
+    renderSites,
+    wholeFilePartialsByBase
+  };
+}
+function parsePartialPath(relativePath) {
+  const withoutSuffix = relativePath.slice(0, -EJS_SUFFIX.length);
+  const partialStart = withoutSuffix.lastIndexOf("_");
+  const partialName = withoutSuffix.slice(partialStart + 1);
+  const prefix = withoutSuffix.slice(0, partialStart);
+  const sectionStart = prefix.lastIndexOf("@");
+  if (sectionStart === -1) {
+    return {
+      basePath: prefix,
+      partialName,
+      path: relativePath,
+      section: null
+    };
+  }
+  return {
+    basePath: prefix.slice(0, sectionStart),
+    partialName,
+    path: relativePath,
+    section: prefix.slice(sectionStart + 1)
+  };
+}
+function defaultTemplatesDir() {
+  return join2(getScriptDir(), "..", "templates", "default");
+}
+function getRenderBase(templatePath) {
+  if (!isPartialTemplatePath(templatePath)) {
+    return templatePath;
+  }
+  const { basePath } = parsePartialPath(`${templatePath}${EJS_SUFFIX}`);
+  return isPartialTemplatePath(basePath) ? getRenderBase(basePath) : templatePath;
+}
+function walkTemplates(templatesDir, relativeDir) {
+  const absoluteDir = join2(templatesDir, relativeDir);
+  if (!existsSync3(absoluteDir)) {
+    return [];
+  }
+  const found = [];
+  for (const entry of readdirSync(absoluteDir)) {
+    const relativePath = relativeDir === "" ? entry : `${relativeDir}/${entry}`;
+    if (statSync(join2(templatesDir, relativePath)).isDirectory()) {
+      found.push(...walkTemplates(templatesDir, relativePath));
+    } else {
+      found.push(relativePath);
+    }
+  }
+  return found;
+}
+
+// src/overlay.ts
+var OVERLAY_MANIFEST_FILE_NAME = "overlay.json";
+var OVERLAY_README_FILE_NAME = "README.md";
+var EJS_SUFFIX2 = ".ejs";
+var MANIFEST_KEYS = ["badges", "files", "packages", "partials"];
+var PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+function loadOverlay(dir, builtIn = loadTemplateInventory()) {
+  const absoluteDir = resolve(dir);
+  if (!existsSync4(absoluteDir) || !statSync2(absoluteDir).isDirectory()) {
+    throw new Error(`Custom template directory not found: ${absoluteDir}`);
+  }
+  const manifestPath = join3(absoluteDir, OVERLAY_MANIFEST_FILE_NAME);
+  if (!existsSync4(manifestPath)) {
+    throw new Error(`Custom template directory has no ${OVERLAY_MANIFEST_FILE_NAME}: ${absoluteDir}`);
+  }
+  const manifest = readManifest(manifestPath);
+  const overlay = { ...manifest, dir: absoluteDir };
+  const problems = findOverlayProblems(overlay, loadTemplateInventory(absoluteDir), builtIn);
+  if (problems.length > 0) {
+    throw new Error(`Custom template ${absoluteDir} is not valid:
+${problems.map((problem) => `  - ${problem}`).join("\n")}`);
+  }
+  return overlay;
+}
+function toRecordedOverlayPath(overlayDir, projectDir) {
+  const relativePath = relative(projectDir, overlayDir);
+  return isAbsolute(relativePath) ? relativePath : relativePath.replaceAll("\\", "/");
+}
+function findManifestProblems(overlay, own, builtIn) {
+  const problems = [];
+  const builtInPartialNames = new Set(builtIn.partials.map((partial) => partial.partialName));
+  const builtInFiles = getEmittableFiles(builtIn);
+  const ownFiles = getEmittableFiles(own);
+  for (const name of overlay.partials) {
+    if (!PARTIAL_NAME_PATTERN.test(name)) {
+      problems.push(`Partial "${name}" is not kebab-case, so its files would not be recognized as partials.`);
+    } else if (builtInPartialNames.has(name)) {
+      problems.push(`Partial "${name}" is already a built-in partial name. Partial names are one namespace, so declaring it would pull the built-in "${name}" files into every project. Choose another name.`);
+    } else if (!own.partials.some((partial) => partial.partialName === name)) {
+      problems.push(`Partial "${name}" is declared, but no file in the overlay contributes it.`);
+    }
+  }
+  for (const packageName of overlay.packages) {
+    if (!PACKAGE_NAME_PATTERN.test(packageName)) {
+      problems.push(`Package "${packageName}" is not a valid npm package name. List the name only; its version is resolved at generation time.`);
+    }
+  }
+  for (const badge of overlay.badges) {
+    if (badge.trim() === "" || /[\r\n]/.test(badge)) {
+      problems.push(`Badge ${JSON.stringify(badge)} must be one non-empty line: every badge shares the README's badge line.`);
+    }
+  }
+  for (const path of overlay.files) {
+    if (path.endsWith(EJS_SUFFIX2)) {
+      problems.push(`File "${path}" names a template. List the emitted path, without ${EJS_SUFFIX2}.`);
+    } else if (builtInFiles.has(path)) {
+      problems.push(`File "${path}" is a built-in file. To override it, place its template at the same path; listing it in "files" would emit it whatever the answers are.`);
+    } else if (!ownFiles.has(path)) {
+      problems.push(`File "${path}" is declared, but the overlay has no ${path}${EJS_SUFFIX2} for it.`);
+    }
+  }
+  return problems;
+}
+function findOverlayProblems(overlay, own, builtIn) {
+  return [
+    ...findManifestProblems(overlay, own, builtIn),
+    ...findTemplateProblems(overlay, own, builtIn),
+    ...listStrayFiles(overlay.dir, own).map((path) => `${path} is neither a template (${EJS_SUFFIX2}), an asset, ${OVERLAY_MANIFEST_FILE_NAME} nor the overlay's own ${OVERLAY_README_FILE_NAME}, so it would be ignored.`)
+  ];
+}
+function findTemplateProblems(overlay, own, builtIn) {
+  const problems = [];
+  const builtInPartialPaths = new Set(builtIn.partials.map((partial) => partial.path));
+  const builtInFiles = getEmittableFiles(builtIn);
+  const declaredPartials = new Set(overlay.partials);
+  const declaredFiles = new Set(overlay.files);
+  for (const path of own.directTemplates) {
+    if (!builtInFiles.has(path) && !declaredFiles.has(path)) {
+      problems.push(`${path}${EJS_SUFFIX2} overrides no built-in file and is not listed in "files", so nothing would ever emit it.`);
+    }
+  }
+  for (const path of own.assetTemplates) {
+    if (!builtInFiles.has(path) && !declaredFiles.has(path)) {
+      problems.push(`${path} overrides no built-in file and is not listed in "files", so nothing would ever emit it.`);
+    }
+  }
+  const renderSites = [...builtIn.renderSites, ...own.renderSites];
+  for (const partial of own.partials) {
+    if (builtInPartialPaths.has(partial.path)) {
+      continue;
+    }
+    if (!declaredPartials.has(partial.partialName)) {
+      problems.push(`${partial.path} contributes partial "${partial.partialName}", which is neither declared in "partials" nor a built-in partial file at that path.`);
+      continue;
+    }
+    if (partial.section === null) {
+      if (!builtInFiles.has(partial.basePath) && !declaredFiles.has(partial.basePath)) {
+        problems.push(`${partial.path} composes ${partial.basePath}, which is neither a built-in file nor listed in "files".`);
+      }
+    } else if (!hasRenderSite(renderSites, partial.basePath, partial.section)) {
+      problems.push(`${partial.path} answers render('${partial.section}') in ${partial.basePath}, and no template makes that call.`);
+    }
+  }
+  return problems;
+}
+function getEmittableFiles(inventory) {
+  return /* @__PURE__ */ new Set([...inventory.directTemplates, ...inventory.assetTemplates, ...inventory.wholeFilePartialsByBase.keys()]);
+}
+function hasRenderSite(renderSites, basePath, section) {
+  return renderSites.some((site) => site.section === section && site.basePath === basePath);
+}
+function listStrayFiles(dir, own) {
+  const accounted = /* @__PURE__ */ new Set([
+    ...[...own.directTemplates].map((path) => `${path}${EJS_SUFFIX2}`),
+    ...own.assetTemplates,
+    ...own.partials.map((partial) => partial.path),
+    OVERLAY_MANIFEST_FILE_NAME,
+    OVERLAY_README_FILE_NAME
+  ]);
+  return walkFiles(dir, "").filter((path) => !accounted.has(path));
+}
+function readManifest(manifestPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+  } catch {
+    throw new Error(`${manifestPath} is not valid JSON.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${manifestPath} should contain a JSON object.`);
+  }
+  const record = parsed;
+  for (const key of Object.keys(record)) {
+    if (!MANIFEST_KEYS.includes(key)) {
+      throw new Error(`${manifestPath} has an unknown key "${key}". The keys are: ${MANIFEST_KEYS.join(", ")}.`);
+    }
+  }
+  function readList(key) {
+    const value = record[key] ?? [];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+      throw new Error(`"${key}" in ${manifestPath} should be an array of strings.`);
+    }
+    return value;
+  }
+  return {
+    badges: readList("badges"),
+    files: readList("files"),
+    packages: readList("packages"),
+    partials: readList("partials")
+  };
+}
+function walkFiles(root, relativeDir) {
+  const found = [];
+  for (const entry of readdirSync2(join3(root, relativeDir))) {
+    const relativePath = relativeDir === "" ? entry : `${relativeDir}/${entry}`;
+    if (statSync2(join3(root, relativePath)).isDirectory()) {
+      found.push(...walkFiles(root, relativePath));
+    } else {
+      found.push(relativePath);
+    }
+  }
+  return found;
+}
+
+// src/project-formatter.ts
+import { spawnSync } from "node:child_process";
+import {
+  existsSync as existsSync5,
+  readFileSync as readFileSync5
+} from "node:fs";
+import { join as join4 } from "node:path";
+import process2 from "node:process";
+var FORMATTER_COMMANDS = {
+  biome: {
+    checkArgs: (destinationPath) => ["format", `--stdin-file-path=${destinationPath}`],
+    packageName: "@biomejs/biome",
+    writeArgs: (destinationPaths) => ["format", "--write", "--no-errors-on-unmatched", ...destinationPaths]
+  },
+  prettier: {
+    checkArgs: (destinationPath) => ["--stdin-filepath", destinationPath],
+    packageName: "prettier",
+    writeArgs: (destinationPaths) => ["--write", "--ignore-unknown", ...destinationPaths]
+  }
+};
+function createProjectFormatter(targetDir, formatter) {
+  const cli = FORMATTER_COMMANDS[formatter];
+  if (!needsInitialFormat(formatter) || cli === void 0) {
+    return null;
+  }
+  const binPath = resolveBin(targetDir, cli.packageName);
+  if (binPath === null) {
+    return null;
+  }
+  return {
+    formatContent(destinationPath, content) {
+      return runCli(binPath, targetDir, cli.checkArgs(destinationPath), content);
+    },
+    formatFiles(destinationPaths) {
+      if (destinationPaths.length > 0) {
+        runCli(binPath, targetDir, cli.writeArgs(destinationPaths));
+      }
+    }
+  };
+}
+function resolveBin(targetDir, packageName) {
+  const packageDir = join4(targetDir, "node_modules", packageName);
+  const packageJsonPath = join4(packageDir, "package.json");
+  if (!existsSync5(packageJsonPath)) {
+    return null;
+  }
+  const { bin } = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+  const relativeBin = typeof bin === "string" ? bin : Object.values(bin ?? {})[0];
+  return relativeBin === void 0 ? null : join4(packageDir, relativeBin);
+}
+function runCli(binPath, targetDir, args, input) {
+  const result = spawnSync(process2.execPath, [binPath, ...args], { cwd: targetDir, encoding: "utf-8", input });
+  return result.status === 0 ? result.stdout : null;
+}
+
+// src/main.ts
+var ARGV_OFFSET = 2;
+var JSON_INDENT_SPACES4 = 2;
+var SCRIPT_MODE = 493;
+function assertManifestAnswersAreListable(answers) {
+  const problems = findUnlistableManifestAnswers(answers);
+  if (problems.length === 0) {
+    return answers;
+  }
+  const lines = problems.map((problem) => `"${problem.value}" is not a valid ${problem.key}. ${problem.message}.
+Pass --${problem.key}=<value> to set it yourself.`);
+  exitWithUsageError(lines.join("\n\n"));
+}
+function buildSavedConfig(newConfig, answers, overlay, targetDir) {
+  return overlay ? { ...newConfig, answers, customTemplate: toRecordedOverlayPath(overlay.dir, targetDir) } : { ...newConfig, answers };
+}
+async function checkForUpdates(currentVersion) {
+  const latestVer = await fetchLatestVersion("@mnaoumov/create-obsidian-plugin");
+  if (latestVer !== null && compare(currentVersion, latestVer) < 0) {
+    log4.warn(`Your version is outdated. Latest: ${latestVer}. Update with:
+  npm install -g @mnaoumov/create-obsidian-plugin`);
+  }
+}
+async function detectMode(cliArgs) {
+  if (cliArgs.mode) {
+    return cliArgs.mode;
+  }
+  const configPath = join5(process.cwd(), CONFIG_FILE_NAME);
+  if (existsSync6(configPath)) {
+    if (cliArgs.useDefaults) {
+      exitWithUsageError(`Existing project detected (${CONFIG_FILE_NAME}), and --yes cannot ask whether to update it.
+Pass --mode=update to update it, or --mode=create to scaffold a new plugin beside it.`);
+    }
+    const shouldUpdate = await confirm({
+      message: "Existing project detected. Would you like to update it?"
+    });
+    assertNotCancelled(shouldUpdate);
+    return shouldUpdate ? "update" /* Update */ : "create" /* Create */;
+  }
+  return "create" /* Create */;
+}
+async function ensurePluginIdIsUnlisted(answers, useDefaults) {
+  const s = spinner();
+  s.start("Checking the plugin id against the Community directory...");
+  const listedIds = await fetchCommunityPluginIds();
+  if (listedIds === null) {
+    s.stop("Could not check the plugin id against the Community directory.");
+    log4.warn(`Could not fetch community-plugins.json, so "${answers.pluginId}" was not checked for a collision with a published plugin. The directory rejects a duplicate id, and an id can never be changed once published: check it by hand before submitting.`);
+    return answers;
+  }
+  const collision = validatePluginIdIsUnlisted(answers.pluginId, listedIds);
+  if (collision === void 0) {
+    s.stop("The plugin id is free in the Community directory.");
+    return answers;
+  }
+  s.stop("The plugin id is already taken in the Community directory.");
+  if (useDefaults) {
+    exitWithUsageError(`${collision}.
+Pass --pluginId=<value> to choose another.`);
+  }
+  log4.warn(collision);
+  const choice = await select2({
+    initialValue: "reenter",
+    message: `What should happen to "${answers.pluginId}"?`,
+    options: [
+      { hint: "Every other answer is kept", label: "Choose a different id", value: "reenter" },
+      { hint: "Only if that listed plugin is your own", label: "Keep it anyway", value: "keep" },
+      { label: "Cancel", value: "cancel" }
+    ]
+  });
+  assertNotCancelled(choice);
+  if (choice === "cancel") {
+    cancel3("Aborted.");
+    process.exit(0);
+  }
+  if (choice === "keep") {
+    return answers;
+  }
+  const pluginId = await text2({
+    message: "Plugin id (lowercase, hyphens allowed)",
+    validate: makeUnlistedPluginIdValidator(listedIds)
+  });
+  assertNotCancelled(pluginId);
+  const pluginName = answers.pluginName === makePluginName(answers.pluginId) ? makePluginName(pluginId) : answers.pluginName;
+  return { ...answers, pluginId, pluginName };
+}
+function execAsync(command, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, [], {
+      cwd,
+      shell: true,
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString("utf-8");
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString("utf-8");
+    });
+    child.on("close", (exitCode) => {
+      if (exitCode !== 0) {
+        const error = new Error(`Command failed with exit code ${String(exitCode)}`);
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve2({ stderr, stdout });
+    });
+    child.on("error", reject);
+  });
+}
+function exitWithUsageError(message) {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+}
+function loadOverlayOrExit(dir, hint = "") {
+  try {
+    return loadOverlay(dir);
+  } catch (error) {
+    exitWithUsageError(`${error instanceof Error ? error.message : String(error)}${hint}`);
+  }
+}
+async function main() {
+  const packageJsonPath = join5(getScriptDir(), "..", "package.json");
+  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  const currentVersion = packageJson.version ?? "0.0.0";
+  const m = "\x1B[38;5;135m";
+  const r = "\x1B[0m";
+  const banner = `
+       ${m}\u25C6${r}
+      ${m}\u25C6 \u25C6${r}
+     ${m}\u25C6 \u25C6 \u25C6${r}    ${m}create-obsidian-plugin${r}
+      ${m}\u25C6 \u25C6${r}     ${m}v${currentVersion}${r}
+       ${m}\u25C6${r}      ${m}@mnaoumov${r}
+
+`;
+  let cliArgs;
+  try {
+    cliArgs = parseCliArgs(process.argv.slice(ARGV_OFFSET));
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+  if (cliArgs.showHelp) {
+    process.stdout.write(`${getHelpText()}
+`);
+    return;
+  }
+  process.stdout.write(banner);
+  intro("Let's build an Obsidian plugin!");
+  await checkForUpdates(currentVersion);
+  const mode = await detectMode(cliArgs);
+  if (mode === "create" /* Create */) {
+    await runCreate(currentVersion, cliArgs);
+  } else {
+    await runUpdate(currentVersion, cliArgs);
+  }
+}
+async function offerAnswersExport(answers, customTemplate) {
+  const shell = getShellForPlatform(process.platform);
+  const scriptName = `obsidian-${answers.pluginId}-create${getScriptExtension(shell)}`;
+  const answersFileName = `obsidian-${answers.pluginId}-answers.json`;
+  async function ask() {
+    const choice2 = await select2({
+      initialValue: "generate",
+      message: "Your answers are collected.",
+      options: [
+        { hint: "Scaffold the plugin now", label: "Start generation", value: "generate" },
+        { hint: scriptName, label: "Save a script for non-interactive generation", value: "script" },
+        { hint: answersFileName, label: "Save an answers file for non-interactive generation", value: "answers" }
+      ]
+    });
+    assertNotCancelled(choice2);
+    return choice2;
+  }
+  let choice = await ask();
+  while (choice !== "generate") {
+    if (choice === "script") {
+      const scriptPath = join5(process.cwd(), scriptName);
+      writeFileSync2(scriptPath, formatCreateScript(answers, shell, customTemplate));
+      if (shell === "sh") {
+        chmodSync(scriptPath, SCRIPT_MODE);
+      }
+      log4.success(`Wrote ${scriptName}`);
+      note(formatCreateCommand(answers, shell, customTemplate), "Non-interactive command");
+    } else {
+      writeFileSync2(join5(process.cwd(), answersFileName), formatAnswersJson(answers));
+      log4.success(`Wrote ${answersFileName}`);
+      const overlayFlag = customTemplate ? ` --customTemplate=${customTemplate}` : "";
+      note(`npm create @mnaoumov/obsidian-plugin -- --yes --mode=create --answersFile=${answersFileName}${overlayFlag}`, "Non-interactive command");
+    }
+    choice = await ask();
+  }
+}
+async function resolveExternalVersions(answers, overlay) {
+  const s = spinner();
+  s.start("Resolving versions...");
+  const [resolvedVersions, minAppVersion] = await Promise.all([
+    resolveVersions(buildTemplate(answers, overlay).dependencies),
+    fetchLatestObsidianVersion()
+  ]);
+  s.stop("Versions resolved.");
+  return { minAppVersion, resolvedVersions };
+}
+async function runCreate(currentVersion, cliArgs) {
+  const { answers: suppliedAnswers, customTemplate, useDefaults } = cliArgs;
+  const overlay = customTemplate ? loadOverlayOrExit(resolvePath(customTemplate)) : null;
+  const answers = await ensurePluginIdIsUnlisted(
+    assertManifestAnswersAreListable(useDefaults ? getDefaultAnswers(suppliedAnswers) : await promptAnswers(suppliedAnswers)),
+    useDefaults
+  );
+  if (!useDefaults) {
+    await offerAnswersExport(answers, customTemplate);
+  }
+  const targetDir = join5(process.cwd(), `obsidian-${answers.pluginId}`);
+  if (existsSync6(targetDir) && !cliArgs.force) {
+    if (useDefaults) {
+      exitWithUsageError(`Directory obsidian-${answers.pluginId} already exists, and --yes cannot ask whether to scaffold into it.
+Pass --force to scaffold into it anyway.`);
+    }
+    const shouldContinue = await confirm({
+      initialValue: false,
+      message: `Directory obsidian-${answers.pluginId} already exists. Continue anyway?`
+    });
+    assertNotCancelled(shouldContinue);
+    if (!shouldContinue) {
+      cancel3("Aborted.");
+      process.exit(0);
+    }
+  }
+  const { minAppVersion, resolvedVersions } = await resolveExternalVersions(answers, overlay);
+  const s = spinner();
+  s.start("Scaffolding plugin...");
+  const newConfig = copyTemplates(answers, targetDir, currentVersion, null, resolvedVersions, minAppVersion, overlay);
+  const configPath = join5(targetDir, CONFIG_FILE_NAME);
+  const configWithAnswers = buildSavedConfig(newConfig, answers, overlay, targetDir);
+  writeFileSync2(configPath, `${JSON.stringify(configWithAnswers, null, JSON_INDENT_SPACES4)}
+`);
+  s.stop("Plugin scaffolded.");
+  const isFormatted = useDefaults ? false : await runPostScaffold(targetDir, answers);
+  const pm = answers.packageManager;
+  const dirName = `obsidian-${answers.pluginId}`;
+  const needsInstall = !existsSync6(join5(targetDir, "node_modules"));
+  const needsFormat = needsInitialFormat(answers.formatter) && !isFormatted;
+  const steps = [
+    ...needsInstall ? [getInstallCommand(pm)] : [],
+    ...needsFormat ? [getRunCommand(pm, "format")] : [],
+    getRunCommand(pm, "dev")
+  ];
+  note(`cd ${dirName} && ${steps.join(" && ")}`, "Next steps");
+  outro("Happy coding!");
+}
+async function runInitialFormat(targetDir, answers, isInstalled) {
+  if (!isInstalled || answers.formatter === "none") {
+    return false;
+  }
+  const s = spinner();
+  s.start("Formatting...");
+  try {
+    await execAsync(getRunCommand(answers.packageManager, "format"), targetDir);
+    const configPath = join5(targetDir, CONFIG_FILE_NAME);
+    const config = JSON.parse(readFileSync6(configPath, "utf-8"));
+    writeFileSync2(configPath, `${JSON.stringify(recordHashesOnDisk(targetDir, config), null, JSON_INDENT_SPACES4)}
+`);
+    s.stop("Formatted.");
+    return true;
+  } catch {
+    s.stop("Failed to format. Run `format` manually.");
+    return false;
+  }
+}
+async function runPostScaffold(targetDir, answers) {
+  const pm = answers.packageManager;
+  const installCmd = getInstallCommand(pm);
+  const shouldInstall = await confirm({
+    initialValue: true,
+    message: `Install dependencies with ${pm}?`
+  });
+  assertNotCancelled(shouldInstall);
+  let isInstalled = false;
+  if (shouldInstall) {
+    const s = spinner();
+    s.start("Installing dependencies...");
+    try {
+      await execAsync(installCmd, targetDir);
+      isInstalled = true;
+      s.stop("Dependencies installed.");
+    } catch (error) {
+      s.stop(`Failed to install dependencies. Run \`${installCmd}\` manually.`);
+      if (error instanceof Error && "stderr" in error) {
+        log4.error(String(error.stderr));
+      }
+    }
+  }
+  const isFormatted = await runInitialFormat(targetDir, answers, isInstalled);
+  const shouldGitInit = await confirm({
+    initialValue: true,
+    message: "Initialize a git repository?"
+  });
+  assertNotCancelled(shouldGitInit);
+  if (shouldGitInit) {
+    const s = spinner();
+    s.start("Initializing git repository...");
+    try {
+      await execAsync(`git init -b ${answers.defaultBranch}`, targetDir);
+      await execAsync("git add -A", targetDir);
+      await execAsync('git commit -m "Initial commit from create-obsidian-plugin"', targetDir);
+      s.stop("Git repository initialized with initial commit.");
+    } catch {
+      s.stop("Failed to initialize git. Run `git init` manually.");
+    }
+  }
+  const shouldCreateGitHubRepo = await confirm({
+    initialValue: false,
+    message: "Create a GitHub repository?"
+  });
+  assertNotCancelled(shouldCreateGitHubRepo);
+  if (shouldCreateGitHubRepo) {
+    const s = spinner();
+    s.start("Creating GitHub repository...");
+    try {
+      await execAsync(`gh repo create obsidian-${answers.pluginId} --public --source=. --push`, targetDir);
+      s.stop("GitHub repository created and pushed.");
+    } catch {
+      s.stop("Failed to create GitHub repo. Make sure `gh` CLI is installed and authenticated.");
+    }
+  }
+  return isFormatted;
+}
+async function runUpdate(currentVersion, cliArgs) {
+  const { answers: suppliedAnswers, customTemplate, useDefaults } = cliArgs;
+  const targetDir = process.cwd();
+  const existingConfig = loadConfig(targetDir);
+  if (!existingConfig) {
+    log4.error("No config file found. Cannot update.");
+    process.exit(1);
+  }
+  log4.info(`Current project was generated with v${existingConfig.generatorVersion}`);
+  let overlay = null;
+  if (customTemplate !== void 0) {
+    overlay = customTemplate ? loadOverlayOrExit(resolvePath(customTemplate)) : null;
+  } else if (existingConfig.customTemplate) {
+    overlay = loadOverlayOrExit(
+      resolvePath(targetDir, existingConfig.customTemplate),
+      `
+This project records it in ${CONFIG_FILE_NAME}. Pass --customTemplate=<dir> to point at where it is now, or --customTemplate= to stop using it.`
+    );
+    log4.info(`Applying the custom template recorded for this project: ${existingConfig.customTemplate}`);
+  }
+  const configPath = join5(targetDir, CONFIG_FILE_NAME);
+  const savedConfig = JSON.parse(readFileSync6(configPath, "utf-8"));
+  let answers;
+  if (savedConfig.answers) {
+    const saved = { ...savedConfig.answers, ...suppliedAnswers };
+    log4.info("Using saved answers from previous generation.");
+    const shouldRePrompt = useDefaults ? false : await confirm({
+      initialValue: false,
+      message: "Would you like to change any settings?"
+    });
+    assertNotCancelled(shouldRePrompt);
+    if (shouldRePrompt) {
+      answers = await promptAnswers(saved);
+    } else {
+      answers = saved;
+    }
+  } else {
+    if (useDefaults) {
+      exitWithUsageError(`${CONFIG_FILE_NAME} records no answers, so --yes has none to reuse.
+Run without --yes to answer them again.`);
+    }
+    log4.warn("No saved answers found. Please provide the settings again.");
+    answers = await promptAnswers(suppliedAnswers);
+  }
+  const savedPluginId = savedConfig.answers?.pluginId;
+  if (savedPluginId !== void 0 && answers.pluginId !== savedPluginId) {
+    answers = await ensurePluginIdIsUnlisted(answers, useDefaults);
+  }
+  const { minAppVersion, resolvedVersions } = await resolveExternalVersions(answers, overlay);
+  const projectFormatter = createProjectFormatter(targetDir, answers.formatter);
+  if (projectFormatter === null && needsInitialFormat(answers.formatter)) {
+    log4.warn(`${answers.formatter} is not installed, so the update cannot tell the files it formatted from hand edits and skips them. Install the dependencies and update again to have them updated.`);
+  }
+  const s = spinner();
+  s.start("Updating project files...");
+  copyTemplates(answers, targetDir, currentVersion, existingConfig, resolvedVersions, minAppVersion, overlay, projectFormatter);
+  s.stop("Update complete.");
+  const newConfig = loadConfig(targetDir);
+  if (newConfig) {
+    const configWithAnswers = buildSavedConfig(newConfig, answers, overlay, targetDir);
+    writeFileSync2(configPath, `${JSON.stringify(configWithAnswers, null, JSON_INDENT_SPACES4)}
+`);
+  }
+  outro("Project updated successfully!");
+}
+await main();