jsrepo 1.0.0

package/dist/index.js

@@ -0,0 +1,2179 @@
+// src/index.ts
+import fs11 from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath } from "node:url";
+import { program as program5 } from "commander";
+
+// src/commands/add.ts
+import fs6 from "node:fs";
+import path5 from "node:path";
+import { cancel, confirm, isCancel, multiselect, outro, spinner as spinner2 } from "@clack/prompts";
+import color4 from "chalk";
+import { Command, program as program2 } from "commander";
+import { execa } from "execa";
+import { resolveCommand } from "package-manager-detector/commands";
+import { detect } from "package-manager-detector/detect";
+import * as v4 from "valibot";
+
+// src/blocks/utilities/map-to-array.ts
+var mapToArray = (map, fn) => {
+  const items = [];
+  for (const [key, value] of map) {
+    items.push(fn(key, value));
+  }
+  return items;
+};
+
+// src/config/index.ts
+import fs from "node:fs";
+import * as v from "valibot";
+
+// src/blocks/types/result.ts
+var Result = class {
+  _result;
+  constructor(result) {
+    this._result = result;
+  }
+  /** Allows you to run callbacks based on the result.
+   *
+   * @param success callback to be run when result is success
+   * @param failure callback to be run when result is failure
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.match(
+   * 	(val) => val,
+   * 	() => {
+   * 		throw new Error('oops!')
+   * 	}
+   * );
+   * ```
+   *
+   * ## Examples
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const val = result.match(
+   * 	(val) => val,
+   * 	() => {
+   * 		throw new Error('oops!')
+   * 	}
+   * );
+   *
+   * console.log(val); // "Hello, World!"
+   * ```
+   */
+  match(success, failure) {
+    if (!this._result.ok) {
+      return failure(this._result.err);
+    }
+    return success(this._result.val);
+  }
+  /** Maps `Result<T, E>` to `Result<A, E>` using the passed mapping function
+   *
+   * @param fn Mapping function
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.map((val) => val.length);
+   * ```
+   *
+   * ## Examples
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const hello = result.map((val) => val.slice(0, 5));
+   *
+   * console.log(hello.unwrap()); // "Hello"
+   * ```
+   */
+  map(fn) {
+    return this.match(
+      (val) => Ok(fn(val)),
+      (err) => Err(err)
+    );
+  }
+  /** In the `Ok` case returns the mapped value using the function else returns `defaultVal`
+   *
+   * @param defaultVal Value to be returned when `Err`
+   * @param fn Mapping function to map in case of `Ok`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.mapOr(1, (val) => val.length);
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapOr(1, (val) => val.length);
+   *
+   * console.log(length); // 3
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapOr(1, (val) => val.length);
+   *
+   * console.log(length); // 1
+   * ```
+   */
+  mapOr(defaultVal, fn) {
+    return this.match(
+      (val) => fn(val),
+      (_) => defaultVal
+    );
+  }
+  /** In the `Ok` case returns the mapped value using `fn` else returns value of `def`
+   *
+   * @param def Mapping function called when `Err`
+   * @param fn Mapping function called when `Ok`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.mapOrElse(() => 1, (val) => val.length);
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapOrElse(() => 1, (val) => val.length);
+   *
+   * console.log(length); // 3
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapOr(() => 1, (val) => val.length);
+   *
+   * console.log(length); // 1
+   * ```
+   */
+  mapOrElse(def, fn) {
+    return this.match(
+      (val) => fn(val),
+      (err) => def(err)
+    );
+  }
+  /** Maps `Result<T, E>` to `Result<T, A>` using the passed mapping function
+   *
+   * @param fn Mapping function
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.mapErr((err) => getCodeMsg(err));
+   * ```
+   *
+   * ## Examples
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err(10);
+   *
+   * const result = functionThatMightFail();
+   *
+   * const message = result.mapErr(() => "Error");
+   *
+   * console.log(message); // "Error"
+   * ```
+   */
+  mapErr(fn) {
+    return this.match(
+      (val) => Ok(val),
+      (err) => Err(fn(err))
+    );
+  }
+  /** In the `Err` case returns the mapped value using the function else returns `defaultVal`
+   *
+   * @param defaultVal Value to be returned when `Ok`
+   * @param fn Mapping function to map in case of `Err`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.mapErrOr("Should've been error", (err) => getCodeMsg(err));
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const message = result.mapErrOr("Should've been error", () => "Error");
+   *
+   * console.log(message); // "Should've been error"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err(10);
+   *
+   * const result = functionThatMightFail();
+   *
+   * const message = result.mapErrOr("Should've been error", () => "Error");
+   *
+   * console.log(message); // "Error"
+   * ```
+   */
+  mapErrOr(defaultVal, fn) {
+    return this.match(
+      (_) => defaultVal,
+      (err) => fn(err)
+    );
+  }
+  /** In the `Err` case returns the mapped value using the function else returns value of `def`
+   *
+   * @param def Mapping function called when `Ok`
+   * @param fn Mapping function called when `Err`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.mapErrOrElse(() => "Value", (_) => "Error!");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapErrOrElse(() => 1, (val) => val.length);
+   *
+   * console.log(length); // 1
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * const length = result.mapOr(() => 1, (val) => val.length);
+   *
+   * console.log(length); // 4
+   * ```
+   */
+  mapErrOrElse(def, fn) {
+    return this.match(
+      (val) => def(val),
+      (err) => fn(err)
+    );
+  }
+  /** Returns true if result is `Ok`
+   *
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.isOk();
+   * ```
+   */
+  isOk() {
+    return this.match(
+      () => true,
+      () => false
+    );
+  }
+  /** Returns true if result is `Err`
+   *
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.isErr();
+   * ```
+   */
+  isErr() {
+    return this.match(
+      () => false,
+      () => true
+    );
+  }
+  /** Tries to return value if value is `Err` throws generic error message.
+   *
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrap();
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrap()); // "Hello!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * result.unwrap(); // Error: Attempted to call `.unwrap()` on a non `Ok` value.
+   * ```
+   */
+  unwrap() {
+    return this.match(
+      (val) => val,
+      () => {
+        throw new Error("Attempted to call `.unwrap()` on a non `Ok` value.");
+      }
+    );
+  }
+  /** Tries to return err if value is `Ok` throws generic error message.
+   *
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrapErr();
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * result.unwrapErr(); // Error: Attempted to call `.unwrapErr()` on a non `Err` value.
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapErr()); // "oops!"
+   * ```
+   */
+  unwrapErr() {
+    return this.match(
+      () => {
+        throw new Error("Attempted to call `.unwrapErr()` on a non `Err` value.");
+      },
+      (err) => err
+    );
+  }
+  /** Tries to unwrap the value if value is `Err` returns `defaultVal`
+   *
+   * @param defaultVal Value to be returned if `Err`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrapOr(7);
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapOr("Yellow!")); // "Hello!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapOr("Yellow!")); // "Yellow!"
+   * ```
+   */
+  unwrapOr(defaultVal) {
+    return this.match(
+      (val) => val,
+      (_) => defaultVal
+    );
+  }
+  /** Tries to unwrap the error if vale is `Ok` returns `defaultVal`
+   *
+   * @param defaultVal
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrapErrOr("Error");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapErrOr("Yellow!")); // "Yellow!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapErrOr("Yellow!")); // "oops!"
+   * ```
+   */
+  unwrapErrOr(defaultVal) {
+    return this.match(
+      () => defaultVal,
+      (err) => err
+    );
+  }
+  /** Tries to return the value if value is `Err` calls `fn`
+   *
+   * @param fn Function called if `Err`
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrapOrElse(() => "Hello!");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapOrElse(() => "oops!")); // "Hello!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapOrElse(() => "Hello!")); // "Hello!"
+   * ```
+   *
+   */
+  unwrapOrElse(fn) {
+    return this.match(
+      (val) => val,
+      (err) => fn(err)
+    );
+  }
+  /** Tries to return the error if value is `Ok` calls `fn`
+   *
+   * @param fn Function called if `Ok`
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.unwrapErrOrElse(() => "Error!");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapErrOrElse(() => "oops!")); // "oops!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.unwrapErrOrElse(() => "Hello!")); // "oops!"
+   * ```
+   *
+   */
+  unwrapErrOrElse(fn) {
+    return this.match(
+      (val) => fn(val),
+      (err) => err
+    );
+  }
+  /** Tries to return value if value is `Err` throws custom error message.
+   *
+   * @param message Message to show when value is `Err`
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.expect("Custom message");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.expect("I failed!")); // "Hello!"
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * result.expect("I failed!"); // Error: I failed!
+   * ```
+   */
+  expect(message) {
+    return this.match(
+      (val) => val,
+      () => {
+        throw new Error(message);
+      }
+    );
+  }
+  /** Tries to return error value if value is `Ok` throws custom error message
+   *
+   * @param message
+   * @returns
+   *
+   * ## Usage
+   *
+   * ```ts
+   * result.expectErr("Custom message");
+   * ```
+   *
+   * ## Examples
+   *
+   * ### When `Ok`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.expectErr("I failed!")); // Error: I failed!
+   * ```
+   *
+   * ### When `Err`
+   *
+   * ```ts
+   * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+   *
+   * const result = functionThatMightFail();
+   *
+   * console.log(result.expectErr("I failed!")); // "oops!"
+   * ```
+   */
+  expectErr(message) {
+    return this.match(
+      () => {
+        throw new Error(message);
+      },
+      (err) => err
+    );
+  }
+};
+var Ok = (val) => {
+  return new Result({ ok: true, val });
+};
+var Err = (err) => {
+  return new Result({ ok: false, err });
+};
+
+// src/config/index.ts
+var CONFIG_NAME = "blocks.json";
+var schema = v.object({
+  $schema: v.string(),
+  repos: v.optional(v.array(v.string()), []),
+  includeTests: v.boolean(),
+  path: v.pipe(v.string(), v.minLength(1)),
+  watermark: v.optional(v.boolean(), true)
+});
+var getConfig = () => {
+  if (!fs.existsSync(CONFIG_NAME)) {
+    return Err("Could not find your configuration file! Please run `npx jsrepo init`.");
+  }
+  const config = v.safeParse(schema, JSON.parse(fs.readFileSync(CONFIG_NAME).toString()));
+  if (!config.success) {
+    return Err("There was an error reading your `blocks.json` file!");
+  }
+  return Ok(config.output);
+};
+
+// src/utils/build.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+import color2 from "chalk";
+import { program } from "commander";
+import * as v2 from "valibot";
+
+// src/utils/index.ts
+import color from "chalk";
+var OUTPUT_FILE = "blocks-manifest.json";
+var WARN = color.bgRgb(245, 149, 66).white("WARN");
+var INFO = color.bgBlueBright.white("INFO");
+
+// src/utils/language-support.ts
+import fs3 from "node:fs";
+import { builtinModules } from "node:module";
+import path2 from "node:path";
+import { walk } from "estree-walker";
+import * as sv from "svelte/compiler";
+import { Project } from "ts-morph";
+import validatePackageName from "validate-npm-package-name";
+
+// src/utils/package.ts
+import fs2 from "node:fs";
+import path from "node:path";
+var findNearestPackageJson = (startDir, until) => {
+  const packagePath = path.join(startDir, "package.json");
+  if (fs2.existsSync(packagePath)) return packagePath;
+  if (startDir === until) return void 0;
+  const segments = startDir.split(/[\/\\]/);
+  return findNearestPackageJson(segments.slice(0, segments.length - 1).join("/"), until);
+};
+
+// src/utils/language-support.ts
+var typescript = {
+  matches: (fileName) => fileName.endsWith(".ts") || fileName.endsWith(".js") || fileName.endsWith(".tsx") || fileName.endsWith(".jsx"),
+  resolveDependencies: (filePath, category, isSubDir) => {
+    const project = new Project();
+    const blockFile = project.addSourceFileAtPath(filePath);
+    const imports = blockFile.getImportDeclarations();
+    const relativeImports = imports.filter(
+      (declaration) => declaration.getModuleSpecifierValue().startsWith(".")
+    );
+    const localDeps = /* @__PURE__ */ new Set();
+    for (const relativeImport of relativeImports) {
+      const mod = relativeImport.getModuleSpecifierValue();
+      const localDep = resolveLocalImport(mod, category, isSubDir);
+      if (localDep) localDeps.add(localDep);
+    }
+    const deps = imports.filter((declaration) => !declaration.getModuleSpecifierValue().startsWith(".")).map((declaration) => declaration.getModuleSpecifierValue());
+    const { devDependencies, dependencies } = resolveRemoteDeps(Array.from(deps), filePath);
+    return Ok({
+      local: Array.from(localDeps),
+      dependencies,
+      devDependencies
+    });
+  },
+  comment: (content) => `/*
+${content}
+*/`
+};
+var svelte = {
+  matches: (fileName) => fileName.endsWith(".svelte"),
+  resolveDependencies: (filePath, category, isSubDir) => {
+    const sourceCode = fs3.readFileSync(filePath).toString();
+    const root = sv.parse(sourceCode, { modern: true });
+    if (!root.instance) return Ok({ dependencies: [], devDependencies: [], local: [] });
+    const localDeps = /* @__PURE__ */ new Set();
+    const deps = /* @__PURE__ */ new Set();
+    walk(root.instance, {
+      enter: (node) => {
+        if (node.type === "ImportDeclaration") {
+          if (typeof node.source.value === "string") {
+            if (node.source.value.startsWith(".")) {
+              const localDep = resolveLocalImport(
+                node.source.value,
+                category,
+                isSubDir
+              );
+              if (localDep) localDeps.add(localDep);
+            } else {
+              deps.add(node.source.value);
+            }
+          }
+        }
+      }
+    });
+    const { devDependencies, dependencies } = resolveRemoteDeps(Array.from(deps), filePath);
+    return Ok({
+      dependencies,
+      devDependencies,
+      local: Array.from(localDeps)
+    });
+  },
+  comment: (content) => `<!--
+${content}
+-->`
+};
+var resolveLocalImport = (mod, category, isSubDir) => {
+  if (isSubDir && mod.startsWith("./")) return void 0;
+  if (mod.startsWith("./")) {
+    return `${category}/${path2.parse(path2.basename(mod)).name}`;
+  }
+  if (isSubDir && mod.startsWith("../") && !mod.startsWith("../.")) {
+    return `${category}/${path2.parse(path2.basename(mod)).name}`;
+  }
+  const segments = mod.replaceAll("../", "").split("/");
+  if (segments.length !== 2) return void 0;
+  return `${segments[0]}/${segments[1]}`;
+};
+var resolveRemoteDeps = (deps, filePath) => {
+  const filteredDeps = deps.filter(
+    (dep) => !builtinModules.includes(dep) && !dep.startsWith("node:") && validatePackageName(dep).validForNewPackages
+  );
+  const pkgPath = findNearestPackageJson(path2.dirname(filePath), "");
+  const dependencies = /* @__PURE__ */ new Set();
+  const devDependencies = /* @__PURE__ */ new Set();
+  if (pkgPath) {
+    const { devDependencies: packageDevDependencies, dependencies: packageDependencies } = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    for (const dep of filteredDeps) {
+      let version2 = void 0;
+      if (packageDependencies !== void 0) {
+        version2 = packageDependencies[dep];
+      }
+      if (version2 !== void 0) {
+        dependencies.add(`${dep}@${version2}`);
+        continue;
+      }
+      if (packageDevDependencies !== void 0) {
+        version2 = packageDevDependencies[dep];
+      }
+      if (version2 !== void 0) {
+        devDependencies.add(`${dep}@${version2}`);
+        continue;
+      }
+      dependencies.add(dep);
+    }
+  }
+  return {
+    dependencies: Array.from(dependencies),
+    devDependencies: Array.from(devDependencies)
+  };
+};
+var languages = [typescript, svelte];
+
+// src/utils/build.ts
+var blockSchema = v2.object({
+  name: v2.string(),
+  category: v2.string(),
+  localDependencies: v2.array(v2.string()),
+  dependencies: v2.array(v2.string()),
+  devDependencies: v2.array(v2.string()),
+  tests: v2.boolean(),
+  /** Where to find the block relative to root */
+  directory: v2.string(),
+  subdirectory: v2.boolean(),
+  files: v2.array(v2.string())
+});
+var categorySchema = v2.object({
+  name: v2.string(),
+  blocks: v2.array(blockSchema)
+});
+var TEST_SUFFIXES = [".test.ts", "_test.ts", ".test.js", "_test.js"];
+var isTestFile = (file) => TEST_SUFFIXES.find((suffix) => file.endsWith(suffix)) !== void 0;
+var buildBlocksDirectory = (blocksPath, cwd) => {
+  let paths;
+  try {
+    paths = fs4.readdirSync(blocksPath);
+  } catch {
+    program.error(color2.red(`Couldn't read the ${color2.bold(blocksPath)} directory.`));
+  }
+  const categories = [];
+  for (const categoryPath of paths) {
+    const categoryDir = path3.join(blocksPath, categoryPath);
+    if (fs4.statSync(categoryDir).isFile()) continue;
+    const categoryName = path3.basename(categoryPath);
+    const category = {
+      name: categoryName,
+      blocks: []
+    };
+    const files = fs4.readdirSync(categoryDir);
+    for (const file of files) {
+      const blockDir = path3.join(categoryDir, file);
+      if (fs4.statSync(blockDir).isFile()) {
+        if (isTestFile(file)) continue;
+        const lang = languages.find((resolver) => resolver.matches(file));
+        if (!lang) {
+          console.warn(
+            `${WARN} Skipped \`${color2.bold(blockDir)}\` \`${color2.bold(
+              path3.parse(file).ext
+            )}\` files are not currently supported!`
+          );
+          continue;
+        }
+        const name2 = path3.parse(path3.basename(file)).name;
+        const testsPath = files.find(
+          (f) => TEST_SUFFIXES.find((suffix) => f === `${name2}${suffix}`)
+        );
+        const { dependencies, devDependencies, local } = lang.resolveDependencies(blockDir, categoryName, false).match(
+          (val) => val,
+          (err) => {
+            program.error(color2.red(err));
+          }
+        );
+        const block = {
+          name: name2,
+          directory: path3.relative(cwd, categoryDir),
+          category: categoryName,
+          tests: testsPath !== void 0,
+          subdirectory: false,
+          files: [file],
+          localDependencies: local,
+          dependencies,
+          devDependencies
+        };
+        if (testsPath !== void 0) {
+          block.files.push(testsPath);
+        }
+        category.blocks.push(block);
+      } else {
+        const blockName = file;
+        const blockFiles = fs4.readdirSync(blockDir);
+        const hasTests = blockFiles.findIndex((f) => isTestFile(f)) !== -1;
+        const localDepsSet = /* @__PURE__ */ new Set();
+        const depsSet = /* @__PURE__ */ new Set();
+        const devDepsSet = /* @__PURE__ */ new Set();
+        for (const f of blockFiles) {
+          if (isTestFile(f)) continue;
+          const lang = languages.find((resolver) => resolver.matches(f));
+          if (!lang) {
+            console.warn(
+              `${WARN} Skipped \`${color2.bold(path3.join(blockDir, f))}\` \`${color2.bold(
+                path3.parse(file).ext
+              )}\` files are not currently supported!`
+            );
+            continue;
+          }
+          const { local, dependencies, devDependencies } = lang.resolveDependencies(path3.join(blockDir, f), categoryName, true).match(
+            (val) => val,
+            (err) => {
+              program.error(color2.red(err));
+            }
+          );
+          for (const dep of local) {
+            localDepsSet.add(dep);
+          }
+          for (const dep of dependencies) {
+            depsSet.add(dep);
+          }
+          for (const dep of devDependencies) {
+            devDepsSet.add(dep);
+          }
+        }
+        const block = {
+          name: blockName,
+          directory: path3.relative(cwd, blockDir),
+          category: categoryName,
+          tests: hasTests,
+          subdirectory: true,
+          files: [...blockFiles],
+          localDependencies: Array.from(localDepsSet.keys()),
+          dependencies: Array.from(depsSet.keys()),
+          devDependencies: Array.from(devDepsSet.keys())
+        };
+        category.blocks.push(block);
+      }
+    }
+    categories.push(category);
+  }
+  return categories;
+};
+
+// src/utils/get-installed-blocks.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+var getInstalledBlocks = (blocks, config) => {
+  const installedBlocks = [];
+  for (const [_, block] of blocks) {
+    const baseDir = path4.join(config.path, block.category);
+    let blockPath = path4.join(baseDir, block.files[0]);
+    if (block.subdirectory) {
+      blockPath = path4.join(baseDir, block.name);
+    }
+    if (fs5.existsSync(blockPath))
+      installedBlocks.push({
+        specifier: `${block.category}/${block.name}`,
+        path: blockPath
+      });
+  }
+  return installedBlocks;
+};
+
+// src/utils/get-watermark.ts
+var getWatermark = (version2, repoUrl) => {
+  return `	jsrepo ${version2}
+	Installed from ${repoUrl}
+	${(/* @__PURE__ */ new Date()).toLocaleDateString().replaceAll("/", "-")}`;
+};
+
+// src/utils/git-providers.ts
+import { Octokit } from "octokit";
+import * as v3 from "valibot";
+var octokit = new Octokit({});
+var github = {
+  name: () => "github",
+  resolveRaw: async (repoPath, resourcePath) => {
+    let info;
+    if (typeof repoPath === "string") {
+      info = await github.info(repoPath);
+    } else {
+      info = repoPath;
+    }
+    return new URL(
+      resourcePath,
+      `https://raw.githubusercontent.com/${info.owner}/${info.repoName}/refs/${info.refs}/${info.ref}/`
+    );
+  },
+  info: async (repoPath) => {
+    const repo = repoPath.replaceAll(/(https:\/\/github.com\/)|(github\/)/g, "");
+    const [owner, repoName, ...rest] = repo.split("/");
+    let ref = "main";
+    if (rest[0] === "tree") {
+      ref = rest[1];
+    }
+    let refs = "heads";
+    if (ref !== "main") {
+      try {
+        const { data: tags } = await octokit.rest.git.listMatchingRefs({
+          owner,
+          repo: repoName,
+          ref: "tags"
+        });
+        if (tags.some((tag) => tag.ref === `refs/tags/${ref}`)) {
+          refs = "tags";
+        }
+      } catch {
+        refs = "heads";
+      }
+    }
+    return {
+      refs,
+      url: repoPath,
+      name: github.name(),
+      repoName,
+      owner,
+      ref,
+      provider: github
+    };
+  },
+  matches: (repoPath) => repoPath.toLowerCase().startsWith("https://github.com") || repoPath.toLowerCase().startsWith("github")
+};
+var getProviderInfo = async (repo) => {
+  if (github.matches(repo)) {
+    return Ok(await github.info(repo));
+  }
+  return Err("Only GitHub repositories are supported at this time!");
+};
+var getManifest = async (url) => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return Err(
+        `There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+      );
+    }
+    const categories = v3.parse(v3.array(categorySchema), await response.json());
+    return Ok(categories);
+  } catch {
+    return Err(
+      `There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+    );
+  }
+};
+
+// src/utils/prompts.ts
+import { intro, spinner } from "@clack/prompts";
+import color3 from "chalk";
+
+// src/blocks/utilities/strip-ansi.ts
+import ansiRegex from "ansi-regex";
+var stripAsni = (str) => str.replace(ansiRegex(), "");
+
+// src/blocks/utilities/pad.ts
+var leftPadMin = (str, length, padWith = " ") => {
+  if (stripAsni(str).length > length)
+    throw new Error("String length is greater than the length provided.");
+  return padWith.repeat(length - stripAsni(str).length) + str;
+};
+var rightPad = (str, space, padWith = " ") => {
+  return str + padWith.repeat(space);
+};
+var rightPadMin = (str, length, padWith = " ") => {
+  if (stripAsni(str).length > length)
+    throw new Error("String length is greater than the length provided.");
+  return str + padWith.repeat(length - stripAsni(str).length);
+};
+
+// src/utils/prompts.ts
+var VERTICAL_BORDER = color3.gray("\u2502");
+var HORIZONTAL_BORDER = color3.gray("\u2500");
+var TOP_RIGHT_CORNER = color3.gray("\u2510");
+var BOTTOM_RIGHT_CORNER = color3.gray("\u2518");
+var JUNCTION_RIGHT = color3.gray("\u251C");
+var runTasks = async (tasks, { verbose = false }) => {
+  const loading = spinner();
+  for (const task of tasks) {
+    if (!verbose) loading.start(task.loadingMessage);
+    try {
+      await task.run();
+    } catch (err) {
+      console.error(err);
+    }
+    if (!verbose) loading.stop(task.completedMessage);
+  }
+};
+var nextSteps = (steps) => {
+  let max = 20;
+  steps.map((val) => {
+    const reset = rightPad(stripAsni(val), 4);
+    if (reset.length > max) max = reset.length;
+  });
+  const NEXT_STEPS = "Next Steps";
+  let result = `${VERTICAL_BORDER}
+`;
+  result += `${JUNCTION_RIGHT}  ${NEXT_STEPS} ${HORIZONTAL_BORDER.repeat(
+    max - NEXT_STEPS.length - 1
+  )}${TOP_RIGHT_CORNER}
+`;
+  result += `${VERTICAL_BORDER} ${" ".repeat(max)} ${VERTICAL_BORDER}
+`;
+  steps.map((step) => {
+    result += `${VERTICAL_BORDER}  ${rightPadMin(step, max - 1)} ${VERTICAL_BORDER}
+`;
+  });
+  result += `${VERTICAL_BORDER} ${" ".repeat(max)} ${VERTICAL_BORDER}
+`;
+  result += `${JUNCTION_RIGHT}${HORIZONTAL_BORDER.repeat(max + 2)}${BOTTOM_RIGHT_CORNER}
+`;
+  return result;
+};
+var _intro = (version2) => intro(`${color3.bgHex("#f7df1e").black(" jsrepo ")}${color3.gray(` v${version2} `)}`);
+
+// src/commands/add.ts
+var schema2 = v4.object({
+  yes: v4.boolean(),
+  verbose: v4.boolean(),
+  repo: v4.optional(v4.string()),
+  allow: v4.boolean()
+});
+var add = new Command("add").argument("[blocks...]", "Whichever block you want to add to your project.").option("-y, --yes", "Add and install any required dependencies.", false).option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--repo <repo>", "Repository to download the blocks from").option("--verbose", "Include debug logs.", false).action(async (blockNames, opts) => {
+  const options = v4.parse(schema2, opts);
+  await _add(blockNames, options);
+});
+var _add = async (blockNames, options) => {
+  _intro(context.package.version);
+  const verbose = (msg) => {
+    if (options.verbose) {
+      console.info(`${INFO} ${msg}`);
+    }
+  };
+  verbose(`Attempting to add ${JSON.stringify(blockNames)}`);
+  const loading = spinner2();
+  const config = getConfig().match(
+    (val) => val,
+    (err) => program2.error(color4.red(err))
+  );
+  const blocksMap = /* @__PURE__ */ new Map();
+  let repoPaths = config.repos;
+  if (options.repo) repoPaths = [options.repo];
+  if (!options.allow && options.repo) {
+    const result = await confirm({
+      message: `Allow ${color4.cyan("jsrepo")} to download and run code from ${color4.cyan(options.repo)}?`,
+      initialValue: true
+    });
+    if (isCancel(result) || !result) {
+      cancel("Canceled!");
+      process.exit(0);
+    }
+  }
+  verbose(`Fetching blocks from ${color4.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.start(`Fetching blocks from ${color4.cyan(repoPaths.join(", "))}`);
+  for (const repo of repoPaths) {
+    const providerInfo = (await getProviderInfo(repo)).match(
+      (info) => info,
+      (err) => {
+        loading.stop(`Failed fetching blocks from ${color4.cyan(repo)}`);
+        program2.error(color4.red(err));
+      }
+    );
+    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+    verbose(`Got info for provider ${color4.cyan(providerInfo.name)}`);
+    const categories = (await getManifest(manifestUrl)).match(
+      (val) => val,
+      (err) => {
+        loading.stop(`Failed fetching blocks from ${color4.cyan(repo)}`);
+        program2.error(color4.red(err));
+      }
+    );
+    for (const category of categories) {
+      for (const block of category.blocks) {
+        blocksMap.set(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+          {
+            ...block,
+            sourceRepo: providerInfo
+          }
+        );
+      }
+    }
+  }
+  verbose(`Retrieved blocks from ${color4.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.stop(`Retrieved blocks from ${color4.cyan(repoPaths.join(", "))}`);
+  const installedBlocks = getInstalledBlocks(blocksMap, config).map((val) => val.specifier);
+  let installingBlockNames = blockNames;
+  if (installingBlockNames.length === 0) {
+    const promptResult = await multiselect({
+      message: "Select which blocks to add.",
+      options: Array.from(blocksMap.entries()).map(([key, value]) => {
+        const shortName = `${value.category}/${value.name}`;
+        const blockExists = installedBlocks.findIndex((block) => block === shortName) !== -1;
+        let label;
+        if (repoPaths.length > 1) {
+          label = `${color4.cyan(
+            `${value.sourceRepo.name}/${value.sourceRepo.owner}/${value.sourceRepo.repoName}/${value.category}`
+          )}/${value.name}`;
+        } else {
+          label = `${color4.cyan(value.category)}/${value.name}`;
+        }
+        return {
+          label: blockExists ? color4.gray(label) : label,
+          value: key,
+          // show hint for `Installed` if block is already installed
+          hint: blockExists ? "Installed" : void 0
+        };
+      }),
+      required: true
+    });
+    if (isCancel(promptResult)) {
+      cancel("Canceled!");
+      process.exit(0);
+    }
+    installingBlockNames = promptResult;
+  }
+  verbose(`Installing blocks ${color4.cyan(installingBlockNames.join(", "))}`);
+  if (options.verbose) console.log("Blocks map: ", blocksMap);
+  const installingBlocks = await getBlocks(installingBlockNames, blocksMap, repoPaths);
+  const pm = (await detect({ cwd: process.cwd() }))?.agent ?? "npm";
+  const tasks = [];
+  const devDeps = /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  for (const { name: specifier, block } of installingBlocks) {
+    const watermark = getWatermark(context.package.version, block.sourceRepo.url);
+    const providerInfo = block.sourceRepo;
+    verbose(`Attempting to add ${specifier}`);
+    const directory = path5.join(config.path, block.category);
+    verbose(`Creating directory ${color4.bold(directory)}`);
+    const blockExists = !block.subdirectory && fs6.existsSync(path5.join(directory, block.files[0])) || block.subdirectory && fs6.existsSync(path5.join(directory, block.name));
+    if (blockExists && !options.yes) {
+      const result = await confirm({
+        message: `${color4.bold(block.name)} already exists in your project would you like to overwrite it?`,
+        initialValue: false
+      });
+      if (isCancel(result) || !result) {
+        cancel("Canceled!");
+        process.exit(0);
+      }
+    }
+    tasks.push({
+      loadingMessage: `Adding ${specifier}`,
+      completedMessage: `Added ${specifier}`,
+      run: async () => {
+        fs6.mkdirSync(directory, { recursive: true });
+        const files = [];
+        const getSourceFile = async (filePath) => {
+          const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
+          const response = await fetch(rawUrl);
+          if (!response.ok) {
+            loading.stop(color4.red(`Error fetching ${color4.bold(rawUrl.href)}`));
+            program2.error(color4.red(`There was an error trying to get ${specifier}`));
+          }
+          return await response.text();
+        };
+        for (const sourceFile of block.files) {
+          if (!config.includeTests && isTestFile(sourceFile)) continue;
+          const sourcePath = path5.join(block.directory, sourceFile);
+          let destPath;
+          if (block.subdirectory) {
+            destPath = path5.join(config.path, block.category, block.name, sourceFile);
+          } else {
+            destPath = path5.join(config.path, block.category, sourceFile);
+          }
+          const content = await getSourceFile(sourcePath);
+          fs6.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
+            recursive: true
+          });
+          files.push({ content, destPath });
+        }
+        for (const file of files) {
+          let content = file.content;
+          if (config.watermark) {
+            const lang = languages.find((lang2) => lang2.matches(file.destPath));
+            if (lang) {
+              const comment = lang.comment(watermark);
+              content = `${comment}
+
+${content}`;
+            }
+          }
+          fs6.writeFileSync(file.destPath, content);
+        }
+        if (config.includeTests) {
+          verbose("Trying to include tests");
+          const { devDependencies } = JSON.parse(
+            fs6.readFileSync("package.json").toString()
+          );
+          if (devDependencies.vitest === void 0) {
+            devDeps.add("vitest");
+          }
+        }
+        for (const dep of block.devDependencies) {
+          devDeps.add(dep);
+        }
+        for (const dep of block.dependencies) {
+          deps.add(dep);
+        }
+      }
+    });
+  }
+  await runTasks(tasks, { verbose: options.verbose });
+  const installDependencies = async (deps2, dev) => {
+    if (!options.verbose) loading.start(`Installing dependencies with ${color4.cyan(pm)}`);
+    let add2;
+    if (dev) {
+      add2 = resolveCommand(pm, "install", [...deps2, "-D"]);
+    } else {
+      add2 = resolveCommand(pm, "install", [...deps2]);
+    }
+    if (add2 == null) {
+      program2.error(color4.red(`Could not resolve add command for '${pm}'.`));
+    }
+    try {
+      await execa(add2.command, [...add2.args], { cwd: process.cwd() });
+    } catch {
+      program2.error(
+        color4.red(
+          `Failed to install ${color4.bold("vitest")}! Failed while running '${color4.bold(
+            `${add2.command} ${add2.args.join(" ")}`
+          )}'`
+        )
+      );
+    }
+    if (!options.verbose) loading.stop(`Installed ${color4.cyan(deps2.join(", "))}`);
+  };
+  const hasDependencies = deps.size > 0 || devDeps.size > 0;
+  if (hasDependencies) {
+    let install = options.yes;
+    if (!options.yes) {
+      const result = await confirm({
+        message: "Would you like to install dependencies?",
+        initialValue: true
+      });
+      if (isCancel(result)) {
+        cancel("Canceled!");
+        process.exit(0);
+      }
+      install = result;
+    }
+    if (install) {
+      if (deps.size > 0) {
+        await installDependencies(Array.from(deps), false);
+      }
+      if (devDeps.size > 0) {
+        await installDependencies(Array.from(devDeps), true);
+      }
+    }
+    let steps = [];
+    if (!install) {
+      if (deps.size > 0) {
+        const cmd = resolveCommand(pm, "install", [...deps]);
+        steps.push(
+          `Install dependencies \`${color4.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+        );
+      }
+      if (devDeps.size > 0) {
+        const cmd = resolveCommand(pm, "install", [...devDeps, "-D"]);
+        steps.push(
+          `Install dev dependencies \`${color4.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+        );
+      }
+    }
+    steps = steps.map((step, i) => `${i + 1}. ${step}`);
+    if (!install) {
+      steps.push("");
+    }
+    steps.push(`Import the blocks from \`${color4.cyan(config.path)}\``);
+    const next = nextSteps(steps);
+    process.stdout.write(next);
+  }
+  outro(color4.green("All done!"));
+};
+var getBlocks = async (blockSpecifiers, blocksMap, repoPaths) => {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const blockSpecifier of blockSpecifiers) {
+    let block = void 0;
+    if (!blockSpecifier.startsWith("github")) {
+      if (repoPaths.length === 0) {
+        program2.error(
+          color4.red(
+            `If your config doesn't repos then you must provide the repo in the block specifier ex: \`${color4.bold(
+              `github/<owner>/<name>/${blockSpecifier}`
+            )}\`!`
+          )
+        );
+      }
+      for (const repo of repoPaths) {
+        const providerInfo = (await getProviderInfo(repo)).unwrap();
+        const tempBlock = blocksMap.get(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier}`
+        );
+        if (tempBlock === void 0) continue;
+        block = tempBlock;
+        break;
+      }
+    } else {
+      if (repoPaths.length === 0) {
+        const [providerName, owner, repoName, ...rest] = blockSpecifier.split("/");
+        let repo;
+        if (rest.length > 2) {
+          repo = `${providerName}/${owner}/${repoName}/${rest.join("/")}`;
+        } else {
+          repo = `${providerName}/${owner}/${repoName}`;
+        }
+        const providerInfo = (await getProviderInfo(repo)).match(
+          (val) => val,
+          (err) => program2.error(color4.red(err))
+        );
+        const manifestUrl = await providerInfo.provider.resolveRaw(
+          providerInfo,
+          OUTPUT_FILE
+        );
+        const categories = (await getManifest(manifestUrl)).match(
+          (val) => val,
+          (err) => program2.error(color4.red(err))
+        );
+        for (const category of categories) {
+          for (const block2 of category.blocks) {
+            blocksMap.set(
+              `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block2.name}`,
+              {
+                ...block2,
+                sourceRepo: providerInfo
+              }
+            );
+          }
+        }
+      }
+      block = blocksMap.get(blockSpecifier);
+    }
+    if (!block) {
+      program2.error(
+        color4.red(`Invalid block! ${color4.bold(blockSpecifier)} does not exist!`)
+      );
+    }
+    blocks.set(blockSpecifier, { name: blockSpecifier, subDependency: false, block });
+    if (block.localDependencies && block.localDependencies.length > 0) {
+      const subDeps = await getBlocks(
+        block.localDependencies.filter((dep) => blocks.has(dep)),
+        blocksMap,
+        repoPaths
+      );
+      for (const dep of subDeps) {
+        blocks.set(dep.name, dep);
+      }
+    }
+  }
+  return mapToArray(blocks, (_, val) => val);
+};
+
+// src/commands/build.ts
+import fs7 from "node:fs";
+import path6 from "node:path";
+import { outro as outro2, spinner as spinner3 } from "@clack/prompts";
+import color5 from "chalk";
+import { Command as Command2 } from "commander";
+import * as v5 from "valibot";
+var schema3 = v5.object({
+  verbose: v5.boolean(),
+  output: v5.boolean(),
+  dirs: v5.array(v5.string()),
+  cwd: v5.string()
+});
+var build = new Command2("build").description(`Builds the provided --dirs in the project root into a \`${OUTPUT_FILE}\` file.`).option("--dirs [dirs...]", "The directories containing the blocks.", ["./blocks"]).option("--no-output", `Do not output a \`${OUTPUT_FILE}\` file.`).option("--verbose", "Include debug logs.", false).option("--cwd <cwd>", "The current working directory", process.cwd()).action(async (opts) => {
+  const options = v5.parse(schema3, opts);
+  await _build(options);
+});
+var _build = async (options) => {
+  _intro(context.package.version);
+  const loading = spinner3();
+  const categories = [];
+  const outFile = path6.join(options.cwd, OUTPUT_FILE);
+  for (const dir of options.dirs) {
+    const dirPath = path6.join(options.cwd, dir);
+    loading.start(`Building ${color5.cyan(dirPath)}`);
+    if (options.output && fs7.existsSync(outFile)) fs7.rmSync(outFile);
+    categories.push(...buildBlocksDirectory(dirPath, options.cwd));
+    loading.stop(`Built ${color5.cyan(dirPath)}`);
+  }
+  const categoriesMap = /* @__PURE__ */ new Map();
+  for (const category of categories) {
+    const cat = categoriesMap.get(category.name);
+    if (!cat) {
+      categoriesMap.set(category.name, category);
+      continue;
+    }
+    cat.blocks = [...cat.blocks, ...category.blocks];
+    categoriesMap.set(cat.name, cat);
+  }
+  if (options.output) {
+    fs7.writeFileSync(outFile, JSON.stringify(categories, null, "	"));
+  } else {
+    loading.stop("Built successfully!");
+  }
+  outro2(color5.green("All done!"));
+};
+
+// src/commands/diff.ts
+import fs8 from "node:fs";
+import path7 from "node:path";
+import { cancel as cancel2, confirm as confirm2, isCancel as isCancel2, outro as outro3, spinner as spinner4 } from "@clack/prompts";
+import color7 from "chalk";
+import { Command as Command3, program as program3 } from "commander";
+import { diffLines } from "diff";
+import * as v6 from "valibot";
+
+// src/utils/diff.ts
+import color6 from "chalk";
+import { diffChars } from "diff";
+
+// src/blocks/utilities/array-sum.ts
+var arraySum = (arr, fn) => {
+  let total = 0;
+  for (const item of arr) {
+    total = total + fn(item);
+  }
+  return total;
+};
+
+// src/blocks/utilities/lines.ts
+import os from "node:os";
+var NEW_LINE_REGEX = /\n|\r\n/g;
+var get = (str) => str.split(NEW_LINE_REGEX);
+var join = (lines, { lineNumbers = false, prefix } = {}) => {
+  let transformed = lines;
+  if (lineNumbers) {
+    const length = lines.length.toString().length + 1;
+    transformed = transformed.map((line, i) => `${leftPadMin(`${i + 1}`, length)} ${line}`);
+  }
+  if (prefix !== void 0) {
+    transformed = transformed.map((line, i) => `${prefix(i, lines.length)}${line}`);
+  }
+  return transformed.join(os.EOL);
+};
+
+// src/utils/diff.ts
+var formatDiff = ({
+  from,
+  to,
+  changes,
+  expand = false,
+  maxUnchanged = 5,
+  colorRemoved = color6.red,
+  colorAdded = color6.green,
+  prefix,
+  onUnchanged,
+  intro: intro2
+}) => {
+  let result = "";
+  const length = arraySum(changes, (change) => change.count ?? 0).toString().length + 1;
+  let lineOffset = 0;
+  if (changes.length === 1 && !changes[0].added && !changes[0].removed) {
+    return onUnchanged({
+      from,
+      to,
+      changes,
+      expand,
+      maxUnchanged,
+      colorAdded,
+      colorRemoved,
+      prefix,
+      onUnchanged,
+      intro: intro2
+    });
+  }
+  result += intro2({
+    from,
+    to,
+    changes,
+    expand,
+    maxUnchanged,
+    colorAdded,
+    colorRemoved,
+    prefix,
+    onUnchanged,
+    intro: intro2
+  });
+  const linePrefix = (line) => color6.gray(`${prefix?.() ?? ""}${leftPadMin(`${line + 1 + lineOffset} `, length)} `);
+  for (let i = 0; i < changes.length; i++) {
+    const change = changes[i];
+    const hasPreviousChange = changes[i - 1]?.added || changes[i - 1]?.removed;
+    const hasNextChange = changes[i + 1]?.added || changes[i + 1]?.removed;
+    if (!change.added && !change.removed) {
+      if (!expand && change.count !== void 0 && change.count > maxUnchanged) {
+        const prevLineOffset = lineOffset;
+        const ls = get(change.value.trimEnd());
+        let shownLines = 0;
+        if (hasNextChange) shownLines += maxUnchanged;
+        if (hasPreviousChange) shownLines += maxUnchanged;
+        if (shownLines >= ls.length) {
+          result += `${join(ls, {
+            prefix: linePrefix
+          })}
+`;
+          lineOffset += ls.length;
+          continue;
+        }
+        if (hasPreviousChange) {
+          result += `${join(ls.slice(0, maxUnchanged), {
+            prefix: linePrefix
+          })}
+`;
+        }
+        if (ls.length > shownLines) {
+          const count = ls.length - shownLines;
+          result += `${join(
+            get(
+              color6.gray(
+                `+ ${count} more unchanged (${color6.italic("-E to expand")})`
+              )
+            ),
+            {
+              prefix: () => `${prefix?.() ?? ""}${leftPadMin(" ", length)} `
+            }
+          )}
+`;
+        }
+        if (hasNextChange) {
+          lineOffset = lineOffset + ls.length - maxUnchanged;
+          result += `${join(ls.slice(ls.length - maxUnchanged), {
+            prefix: linePrefix
+          })}
+`;
+        }
+        lineOffset = prevLineOffset + change.count;
+        continue;
+      }
+      result += `${join(get(change.value.trimEnd()), {
+        prefix: linePrefix
+      })}
+`;
+      lineOffset += change.count ?? 0;
+      continue;
+    }
+    const colorChange = (change2) => {
+      if (change2.added) {
+        return colorAdded(change2.value.trimEnd());
+      }
+      if (change2.removed) {
+        return colorRemoved(change2.value.trimEnd());
+      }
+      return change2.value;
+    };
+    if (change.removed && change.count === 1) {
+      const diffedChars = diffChars(change.value, changes[i + 1].value);
+      const sentence = diffedChars.map((chg) => colorChange(chg)).join("");
+      result += `${linePrefix(0)}${sentence}`;
+      lineOffset += 1;
+      i++;
+    } else {
+      result += `${join(get(colorChange(change)), {
+        prefix: linePrefix
+      })}
+`;
+      if (!change.removed) {
+        lineOffset += change.count ?? 0;
+      }
+    }
+  }
+  return result;
+};
+
+// src/commands/diff.ts
+var L = color7.gray("\u2502");
+var schema4 = v6.object({
+  allow: v6.boolean(),
+  expand: v6.boolean(),
+  maxUnchanged: v6.number(),
+  repo: v6.optional(v6.string())
+});
+var diff = new Command3("diff").description("Compares local blocks to the blocks in the provided repository.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("-E, --expand", "Expands the diff so you see everything.", false).option("--repo <repo>", "Repository to download the blocks from.").option(
+  "--max-unchanged <number>",
+  "Maximum unchanged lines that will show without being collapsed.",
+  (val) => Number.parseInt(val),
+  // this is such a dumb api thing
+  3
+).action(async (opts) => {
+  const options = v6.parse(schema4, opts);
+  await _diff(options);
+});
+var _diff = async (options) => {
+  _intro(context.package.version);
+  const loading = spinner4();
+  const config = getConfig().match(
+    (val) => val,
+    (err) => program3.error(color7.red(err))
+  );
+  const blocksMap = /* @__PURE__ */ new Map();
+  let repoPaths = config.repos;
+  if (options.repo) repoPaths = [options.repo];
+  if (!options.allow && options.repo) {
+    const result = await confirm2({
+      message: `Allow ${color7.cyan("jsrepo")} to download and run code from ${color7.cyan(options.repo)}?`,
+      initialValue: true
+    });
+    if (isCancel2(result) || !result) {
+      cancel2("Canceled!");
+      process.exit(0);
+    }
+  }
+  loading.start(`Fetching blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  for (const repo of repoPaths) {
+    const providerInfo = (await getProviderInfo(repo)).match(
+      (info) => info,
+      (err) => program3.error(color7.red(err))
+    );
+    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+    const categories = (await getManifest(manifestUrl)).match(
+      (val) => val,
+      (err) => program3.error(color7.red(err))
+    );
+    for (const category of categories) {
+      for (const block of category.blocks) {
+        blocksMap.set(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+          {
+            ...block,
+            sourceRepo: providerInfo
+          }
+        );
+      }
+    }
+  }
+  loading.stop(`Retrieved blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  const installedBlocks = getInstalledBlocks(blocksMap, config);
+  for (const blockSpecifier of installedBlocks) {
+    let found = false;
+    for (const repo of repoPaths) {
+      const providerInfo = (await getProviderInfo(repo)).unwrap();
+      const fullSpecifier = `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier.specifier}`;
+      const block = blocksMap.get(fullSpecifier);
+      if (block === void 0) continue;
+      found = true;
+      process.stdout.write(`${L}
+`);
+      process.stdout.write(`${L}  ${fullSpecifier}
+`);
+      fullSpecifier;
+      for (const file of block.files) {
+        if (!config.includeTests && isTestFile(file)) continue;
+        process.stdout.write(`${L}
+`);
+        const sourcePath = path7.join(block.directory, file);
+        const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, sourcePath);
+        const response = await fetch(rawUrl);
+        if (!response.ok) {
+          program3.error(color7.red(`There was an error trying to get ${fullSpecifier}`));
+        }
+        let remoteContent = await response.text();
+        let localPath = path7.join(config.path, block.category, file);
+        if (block.subdirectory) {
+          localPath = path7.join(config.path, block.category, block.name, file);
+        }
+        let fileContent = "";
+        if (fs8.existsSync(localPath)) {
+          fileContent = fs8.readFileSync(localPath).toString();
+        }
+        if (config.watermark) {
+          const lang = languages.find((lang2) => lang2.matches(sourcePath));
+          if (lang) {
+            const watermark = getWatermark(context.package.version, repo);
+            const comment = lang.comment(watermark);
+            remoteContent = `${comment}
+
+${remoteContent}`;
+          }
+        }
+        const changes = diffLines(fileContent, remoteContent);
+        const from = path7.join(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}`,
+          sourcePath
+        ).replaceAll("\\", "/");
+        const to = localPath.replaceAll("\\", "/");
+        const formattedDiff = formatDiff({
+          from,
+          to,
+          changes,
+          expand: options.expand,
+          maxUnchanged: options.maxUnchanged,
+          colorAdded: color7.greenBright,
+          colorRemoved: color7.redBright,
+          prefix: () => `${L}  `,
+          onUnchanged: ({ from: from2, to: to2, prefix }) => `${prefix?.() ?? ""}${color7.cyan(from2)} \u2192 ${color7.gray(to2)} ${color7.gray("(unchanged)")}
+`,
+          intro: ({ from: from2, to: to2, changes: changes2, prefix }) => {
+            const totalChanges = changes2.filter((a) => a.added).length;
+            return `${prefix?.() ?? ""}${color7.cyan(from2)} \u2192 ${color7.gray(to2)} (${totalChanges} change${totalChanges === 1 ? "" : "s"})
+${prefix?.() ?? ""}
+`;
+          }
+        });
+        process.stdout.write(formattedDiff);
+      }
+      break;
+    }
+    if (!found) {
+      program3.error(
+        color7.red(`Invalid block! ${color7.bold(blockSpecifier)} does not exist!`)
+      );
+    }
+  }
+  outro3(color7.green("All done!"));
+};
+
+// src/commands/init.ts
+import fs9 from "node:fs";
+import { cancel as cancel3, confirm as confirm3, isCancel as isCancel3, outro as outro4, spinner as spinner5, text } from "@clack/prompts";
+import color8 from "chalk";
+import { Command as Command4 } from "commander";
+import * as v7 from "valibot";
+var schema5 = v7.object({
+  path: v7.optional(v7.string()),
+  tests: v7.optional(v7.boolean()),
+  repos: v7.optional(v7.array(v7.string())),
+  watermark: v7.boolean()
+});
+var init = new Command4("init").description("Initializes the configuration file").option("--path <path>", "Path to install the blocks").option("--repos [repos...]", "Repository to install the blocks from").option(
+  "--no-watermark",
+  "Will not add a watermark to each file upon adding it to your project."
+).option("--tests", "Will include tests along with the functions.").action(async (opts) => {
+  const options = v7.parse(schema5, opts);
+  await _init(options);
+});
+var _init = async (options) => {
+  _intro(context.package.version);
+  const initialConfig = getConfig();
+  const loading = spinner5();
+  if (!options.path) {
+    const result = await text({
+      message: "Where should we add the blocks?",
+      validate(value) {
+        if (value.trim() === "") return "Please provide a value";
+      },
+      initialValue: initialConfig.isOk() ? initialConfig.unwrap().path : "src/blocks"
+    });
+    if (isCancel3(result)) {
+      cancel3("Canceled!");
+      process.exit(0);
+    }
+    options.path = result;
+  }
+  if (!options.repos) {
+    options.repos = initialConfig.isOk() ? initialConfig.unwrap().repos : [];
+    while (true) {
+      if (options.repos.length > 0) {
+        const confirmResult = await confirm3({
+          message: "Add another repo?",
+          initialValue: false
+        });
+        if (isCancel3(confirmResult)) {
+          cancel3("Canceled!");
+          process.exit(0);
+        }
+        if (!confirmResult) break;
+      }
+      const result = await text({
+        message: "Where should we download the blocks from?",
+        placeholder: "github/ieedan/std",
+        validate: (val) => {
+          if (!val.startsWith("https://github.com") && !val.startsWith("github/")) {
+            return `Must be a ${color8.bold("GitHub")} repository!`;
+          }
+        }
+      });
+      if (isCancel3(result)) {
+        cancel3("Canceled!");
+        process.exit(0);
+      }
+      options.repos.push(result);
+    }
+  }
+  const config = {
+    $schema: `https://unpkg.com/jsrepo@${context.package.version}/schema.json`,
+    repos: options.repos,
+    path: options.path,
+    includeTests: initialConfig.isOk() && options.tests === void 0 ? initialConfig.unwrap().includeTests : options.tests ?? false,
+    watermark: options.watermark
+  };
+  loading.start(`Writing config to \`${CONFIG_NAME}\``);
+  fs9.writeFileSync(CONFIG_NAME, `${JSON.stringify(config, null, "	")}
+`);
+  fs9.mkdirSync(config.path, { recursive: true });
+  loading.stop(`Wrote config to \`${CONFIG_NAME}\`.`);
+  outro4(color8.green("All done!"));
+};
+
+// src/commands/test.ts
+import fs10 from "node:fs";
+import path8 from "node:path";
+import { cancel as cancel4, confirm as confirm4, isCancel as isCancel4, outro as outro5, spinner as spinner6 } from "@clack/prompts";
+import color9 from "chalk";
+import { Argument, Command as Command5, program as program4 } from "commander";
+import { execa as execa2 } from "execa";
+import { resolveCommand as resolveCommand2 } from "package-manager-detector/commands";
+import { detect as detect2 } from "package-manager-detector/detect";
+import { Project as Project2 } from "ts-morph";
+import * as v8 from "valibot";
+var schema6 = v8.object({
+  debug: v8.boolean(),
+  verbose: v8.boolean(),
+  repo: v8.optional(v8.string()),
+  allow: v8.boolean()
+});
+var test = new Command5("test").description("Tests blocks against most recent tests").addArgument(new Argument("[blocks...]", "Whichever blocks you want to test.").default([])).option("--verbose", "Include debug logs.", false).option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--repo <repo>", "Repository to download the blocks from").option("--debug", "Leaves the temp test file around for debugging upon failure.", false).action(async (blockNames, opts) => {
+  const options = v8.parse(schema6, opts);
+  await _test(blockNames, options);
+});
+var _test = async (blockNames, options) => {
+  _intro(context.package.version);
+  const verbose = (msg) => {
+    if (options.verbose) {
+      console.info(`${INFO} ${msg}`);
+    }
+  };
+  verbose(`Attempting to test ${JSON.stringify(blockNames)}`);
+  const config = getConfig().match(
+    (val) => val,
+    (err) => program4.error(color9.red(err))
+  );
+  const loading = spinner6();
+  const blocksMap = /* @__PURE__ */ new Map();
+  let repoPaths = config.repos;
+  if (options.repo) repoPaths = [options.repo];
+  if (!options.allow && options.repo) {
+    const result = await confirm4({
+      message: `Allow ${color9.cyan("jsrepo")} to download and run code from ${color9.cyan(options.repo)}?`,
+      initialValue: true
+    });
+    if (isCancel4(result) || !result) {
+      cancel4("Canceled!");
+      process.exit(0);
+    }
+  }
+  verbose(`Fetching blocks from ${color9.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.start(`Fetching blocks from ${color9.cyan(repoPaths.join(", "))}`);
+  for (const repo of repoPaths) {
+    const providerInfo = (await getProviderInfo(repo)).match(
+      (info) => info,
+      (err) => program4.error(color9.red(err))
+    );
+    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+    verbose(`Got info for provider ${color9.cyan(providerInfo.name)}`);
+    const response = await fetch(manifestUrl);
+    if (!response.ok) {
+      if (!options.verbose) loading.stop(`Error fetching ${color9.cyan(manifestUrl.href)}`);
+      program4.error(
+        color9.red(
+          `There was an error fetching the \`${OUTPUT_FILE}\` from the repository ${color9.cyan(
+            repo
+          )} make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+        )
+      );
+    }
+    const categories = v8.parse(v8.array(categorySchema), await response.json());
+    for (const category of categories) {
+      for (const block of category.blocks) {
+        blocksMap.set(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+          {
+            ...block,
+            sourceRepo: providerInfo
+          }
+        );
+      }
+    }
+  }
+  verbose(`Retrieved blocks from ${color9.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.stop(`Retrieved blocks from ${color9.cyan(repoPaths.join(", "))}`);
+  const tempTestDirectory = `blocks-tests-temp-${Date.now()}`;
+  verbose(`Trying to create the temp directory ${color9.bold(tempTestDirectory)}.`);
+  fs10.mkdirSync(tempTestDirectory, { recursive: true });
+  const cleanUp = () => {
+    fs10.rmSync(tempTestDirectory, { recursive: true, force: true });
+  };
+  const installedBlocks = getInstalledBlocks(blocksMap, config).map((val) => val.specifier);
+  let testingBlocks = blockNames;
+  if (blockNames.length === 0) {
+    testingBlocks = installedBlocks;
+  }
+  if (testingBlocks.length === 0) {
+    cleanUp();
+    program4.error(color9.red("There were no blocks found in your project!"));
+  }
+  const testingBlocksMapped = [];
+  for (const blockSpecifier of testingBlocks) {
+    let block = void 0;
+    if (!blockSpecifier.startsWith("github")) {
+      for (const repo of repoPaths) {
+        const providerInfo = (await getProviderInfo(repo)).unwrap();
+        const tempBlock = blocksMap.get(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier}`
+        );
+        if (tempBlock === void 0) continue;
+        block = tempBlock;
+        break;
+      }
+    } else {
+      if (repoPaths.length === 0) {
+        const [providerName, owner, repoName, ...rest] = blockSpecifier.split("/");
+        let repo;
+        if (rest.length > 2) {
+          repo = `${providerName}/${owner}/${repoName}/${rest.join("/")}`;
+        } else {
+          repo = `${providerName}/${owner}/${repoName}`;
+        }
+        const providerInfo = (await getProviderInfo(repo)).match(
+          (val) => val,
+          (err) => program4.error(color9.red(err))
+        );
+        const manifestUrl = await providerInfo.provider.resolveRaw(
+          providerInfo,
+          OUTPUT_FILE
+        );
+        const categories = (await getManifest(manifestUrl)).match(
+          (val) => val,
+          (err) => program4.error(color9.red(err))
+        );
+        for (const category of categories) {
+          for (const block2 of category.blocks) {
+            blocksMap.set(
+              `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block2.name}`,
+              {
+                ...block2,
+                sourceRepo: providerInfo
+              }
+            );
+          }
+        }
+      }
+      block = blocksMap.get(blockSpecifier);
+    }
+    if (!block) {
+      program4.error(
+        color9.red(`Invalid block! ${color9.bold(blockSpecifier)} does not exist!`)
+      );
+    }
+    testingBlocksMapped.push({ name: blockSpecifier, block });
+  }
+  for (const { name: specifier, block } of testingBlocksMapped) {
+    const providerInfo = block.sourceRepo;
+    if (!options.verbose) {
+      loading.start(`Setting up test file for ${color9.cyan(specifier)}`);
+    }
+    if (!block.tests) {
+      loading.stop(`No tests found for ${color9.cyan(specifier)}`);
+      continue;
+    }
+    const getSourceFile = async (filePath) => {
+      const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
+      const response = await fetch(rawUrl);
+      if (!response.ok) {
+        loading.stop(color9.red(`Error fetching ${color9.bold(rawUrl.href)}`));
+        program4.error(color9.red(`There was an error trying to get ${specifier}`));
+      }
+      return await response.text();
+    };
+    verbose(`Downloading and copying test files for ${specifier}`);
+    const testFiles = [];
+    for (const testFile of block.files.filter((file) => isTestFile(file))) {
+      const content = await getSourceFile(path8.join(block.directory, testFile));
+      const destPath = path8.join(tempTestDirectory, testFile);
+      fs10.writeFileSync(destPath, content);
+      testFiles.push(destPath);
+    }
+    const directory = path8.join(config.path, block.category);
+    let blockFilePath = path8.join(directory, `${block.name}`);
+    blockFilePath = blockFilePath.replaceAll("\\", "/");
+    verbose(`${color9.bold(specifier)} file path is ${color9.bold(blockFilePath)}`);
+    const project = new Project2();
+    for (const file of testFiles) {
+      verbose(`Opening test file ${file}`);
+      const tempFile = project.addSourceFileAtPath(file);
+      for (const importDeclaration of tempFile.getImportDeclarations()) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        let newModuleSpecifier = void 0;
+        if (moduleSpecifier.startsWith(".")) {
+          if (block.subdirectory) {
+            newModuleSpecifier = path8.join(
+              "../",
+              config.path,
+              block.category,
+              block.name,
+              moduleSpecifier
+            );
+          } else {
+            newModuleSpecifier = path8.join(
+              "../",
+              config.path,
+              block.category,
+              moduleSpecifier
+            );
+          }
+        }
+        if (newModuleSpecifier) {
+          importDeclaration.setModuleSpecifier(newModuleSpecifier.replaceAll(/\\/g, "/"));
+        }
+      }
+    }
+    project.saveSync();
+    verbose(`Completed ${color9.cyan.bold(specifier)} test file`);
+    if (!options.verbose) {
+      loading.stop(`Completed setup for ${color9.bold(specifier)}`);
+    }
+  }
+  verbose("Beginning testing");
+  const pm = await detect2({ cwd: process.cwd() });
+  if (pm == null) {
+    program4.error(color9.red("Could not detect package manager"));
+  }
+  const resolved = resolveCommand2(pm.agent, "execute", ["vitest", "run", tempTestDirectory]);
+  if (resolved == null) {
+    program4.error(color9.red(`Could not resolve add command for '${pm.agent}'.`));
+  }
+  const { command, args } = resolved;
+  const testCommand = `${command} ${args.join(" ")}`;
+  const testingProcess = execa2({
+    cwd: process.cwd(),
+    stdio: ["ignore", "pipe", "pipe"]
+  })`${testCommand}`;
+  const handler = (data) => console.info(data.toString());
+  testingProcess.stdout.on("data", handler);
+  testingProcess.stderr.on("data", handler);
+  try {
+    await testingProcess;
+    cleanUp();
+    outro5(color9.green("All done!"));
+  } catch (err) {
+    if (options.debug) {
+      console.info(
+        `${color9.bold("--debug")} flag provided. Skipping cleanup. Run '${color9.bold(
+          testCommand
+        )}' to retry tests.
+`
+      );
+    } else {
+      cleanUp();
+    }
+    program4.error(color9.red(`Tests failed! Error ${err}`));
+  }
+};
+
+// src/index.ts
+var resolveRelativeToRoot = (p) => {
+  const dirname = fileURLToPath(import.meta.url);
+  return path9.join(dirname, "../..", p);
+};
+var { version, name, description, repository } = JSON.parse(
+  fs11.readFileSync(resolveRelativeToRoot("package.json"), "utf-8")
+);
+var context = {
+  package: {
+    name,
+    description,
+    version,
+    repository
+  },
+  resolveRelativeToRoot
+};
+program5.name(name).description(description).version(version).addCommand(add).addCommand(init).addCommand(test).addCommand(build).addCommand(diff);
+program5.parse();
+export {
+  context
+};