giget 0.1.7 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 - UnJS
+Copyright (c) Pooya Parsa <pooya@pi0.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -36,7 +36,7 @@ npx giget@latest <template> [<dir>] [...options]
 
 ### Options
 
-- `--force`: Clone to exsiting directory even if exists.
+- `--force`: Clone to existing directory even if exists.
 - `--offline`: Do not attempt to download and use cached version.
 - `--prefer-offline`: Use cache if exists otherwise try to download.
 - `--force-clean`: ⚠️ Remove any existing directory or file recusively before cloning.
@@ -89,10 +89,10 @@ A custom registry should provide an endpoint with dynamic path `/:template.json`
 - `tar` (required) Link to the tar download link.
 - `defaultDir`: (optional) Default cloning directory.
 - `url`: (optional) Webpage of the template.
-- `subpath`: (optional) Subpath inside the tar file.
+- `subdir`: (optional) Directory inside the tar file.
 - `headers`: (optional) Custom headers to send while downloading template.
 
-Because of the simplicity, you can even use a github repository as template registry but also you can build something more powerful by bringing your own API.
+Because of the simplicity, you can even use a GitHub repository as template registry but also you can build something more powerful by bringing your own API.
 
 ## Usage (Programmatic)
 
@@ -130,12 +130,12 @@ const { source, dir } = await downloadTemplate('github:unjs/template')
 **Options:**
 
 - `source`: (string) Input source in format of `[provider]:repo[/subpath][#ref]`.
-- `dir`: (string) Destination directory to clone to. If not provided, `user-name` will be used relative to the current directory.
 - `options`: (object) Options are usually inferred from the input string. You can customize them.
+  - `dir`: (string) Destination directory to clone to. If not provided, `user-name` will be used relative to the current directory.
   - `provider`: (string) Either `github`, `gitlab`, `bitbucket` or `sourcehut`. The default is `github`.
   - `repo`: (string) Name of repository in format of `{username}/{reponame}`.
   - `ref`: (string) Git ref (branch or commit or tag). The default value is `main`.
-  - `subdirpath`: (string) subdir of the repo to clone from. The default value is none.
+  - `subdir`: (string) Directory of the repo to clone from. The default value is none.
   - `force`: (boolean) Extract to the exisiting dir even if already exsists.
   - `forceClean`: (boolean) ⚠️ Clean ups any existing directory or file before cloning.
   - `offline`: (boolean) Do not attempt to download and use cached version.
@@ -188,7 +188,7 @@ const { source, dir } = await downloadRepo('themes:test', { providers: { themes
 
 ## Related projects
 
-Giget wouldn't be possible without inspering from former projects. In comparation giget does not depend on any local command which increases stability and performance, supports custom template providers, auth and many more features out of the box.
+Giget wouldn't be possible without inspiration from former projects. In comparison, giget does not depend on any local command which increases stability and performance, supports custom template providers, auth and many more features out of the box.
 
 - https://github.com/samsonjs/gitter
 - https://github.com/tiged/tiged

package/dist/cli.cjs

@@ -4,53 +4,64 @@
 const node_path = require('node:path');
 const mri = require('mri');
 const colorette = require('colorette');
-const giget = require('./shared/giget.3522139c.cjs');
+const giget = require('./shared/giget.51477975.cjs');
 require('node:fs/promises');
-require('node:os');
 require('node:fs');
 require('tar');
 require('pathe');
 require('defu');
 require('node:stream');
 require('node:child_process');
+require('node:os');
 require('node:util');
 require('node-fetch-native');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-const mri__default = /*#__PURE__*/_interopDefaultLegacy(mri);
+require('https-proxy-agent');
 
 async function main() {
-  const args = mri__default(process.argv.slice(2), {
-    boolean: ["help", "force", "force-clean", "offline", "prefer-offline", "shell", "verbose"],
+  const arguments_ = mri(process.argv.slice(2), {
+    boolean: [
+      "help",
+      "force",
+      "force-clean",
+      "offline",
+      "prefer-offline",
+      "shell",
+      "verbose"
+    ],
     string: ["registry", "cwd", "auth"]
   });
-  const input = args._[0];
-  const dir = args._[1];
-  if (!input || args.help || args.h) {
-    console.error("Usage: npx getgit@latest <input> [<dir>] [--force] [--force-clean] [--offline] [--prefer-offline] [--shell] [--registry]  [--no-registry] [--verbose] [--cwd] [--auth]");
+  const input = arguments_._[0];
+  const dir = arguments_._[1];
+  if (!input || arguments_.help || arguments_.h) {
+    console.error(
+      "Usage: npx giget@latest <input> [<dir>] [--force] [--force-clean] [--offline] [--prefer-offline] [--shell] [--registry]  [--no-registry] [--verbose] [--cwd] [--auth]"
+    );
     process.exit(1);
   }
-  if (args.verbose) {
+  if (arguments_.verbose) {
     process.env.DEBUG = process.env.DEBUG || "true";
   }
   const r = await giget.downloadTemplate(input, {
     dir,
-    force: args.force,
-    forceClean: args["force-clean"],
-    offline: args.offline,
-    registry: args.registry,
-    cwd: args.cwd,
-    auth: args.auth
+    force: arguments_.force,
+    forceClean: arguments_["force-clean"],
+    offline: arguments_.offline,
+    registry: arguments_.registry,
+    cwd: arguments_.cwd,
+    auth: arguments_.auth
   });
-  console.log(`\u2728 Successfully cloned ${colorette.cyan(r.name || r.url)} to ${colorette.cyan(node_path.relative(process.cwd(), r.dir))}
-`);
-  if (args.shell) {
+  console.log(
+    `\u2728 Successfully cloned ${colorette.cyan(r.name || r.url)} to ${colorette.cyan(
+      node_path.relative(process.cwd(), r.dir)
+    )}
+`
+  );
+  if (arguments_.shell) {
     giget.startShell(r.dir);
   }
   process.exit(0);
 }
-main().catch((err) => {
-  console.error(err);
+main().catch((error) => {
+  console.error(error);
   process.exit(1);
 });

package/dist/cli.d.ts

@@ -1 +1,2 @@
 
+export { }

package/dist/cli.mjs

@@ -2,49 +2,64 @@
 import { relative } from 'node:path';
 import mri from 'mri';
 import { cyan } from 'colorette';
-import { d as downloadTemplate, s as startShell } from './shared/giget.dd19862e.mjs';
+import { d as downloadTemplate, s as startShell } from './shared/giget.6c52cb03.mjs';
 import 'node:fs/promises';
-import 'node:os';
 import 'node:fs';
 import 'tar';
 import 'pathe';
 import 'defu';
 import 'node:stream';
 import 'node:child_process';
+import 'node:os';
 import 'node:util';
 import 'node-fetch-native';
+import 'https-proxy-agent';
 
 async function main() {
-  const args = mri(process.argv.slice(2), {
-    boolean: ["help", "force", "force-clean", "offline", "prefer-offline", "shell", "verbose"],
+  const arguments_ = mri(process.argv.slice(2), {
+    boolean: [
+      "help",
+      "force",
+      "force-clean",
+      "offline",
+      "prefer-offline",
+      "shell",
+      "verbose"
+    ],
     string: ["registry", "cwd", "auth"]
   });
-  const input = args._[0];
-  const dir = args._[1];
-  if (!input || args.help || args.h) {
-    console.error("Usage: npx getgit@latest <input> [<dir>] [--force] [--force-clean] [--offline] [--prefer-offline] [--shell] [--registry]  [--no-registry] [--verbose] [--cwd] [--auth]");
+  const input = arguments_._[0];
+  const dir = arguments_._[1];
+  if (!input || arguments_.help || arguments_.h) {
+    console.error(
+      "Usage: npx giget@latest <input> [<dir>] [--force] [--force-clean] [--offline] [--prefer-offline] [--shell] [--registry]  [--no-registry] [--verbose] [--cwd] [--auth]"
+    );
     process.exit(1);
   }
-  if (args.verbose) {
+  if (arguments_.verbose) {
     process.env.DEBUG = process.env.DEBUG || "true";
   }
   const r = await downloadTemplate(input, {
     dir,
-    force: args.force,
-    forceClean: args["force-clean"],
-    offline: args.offline,
-    registry: args.registry,
-    cwd: args.cwd,
-    auth: args.auth
+    force: arguments_.force,
+    forceClean: arguments_["force-clean"],
+    offline: arguments_.offline,
+    registry: arguments_.registry,
+    cwd: arguments_.cwd,
+    auth: arguments_.auth
   });
-  console.log(`\u2728 Successfully cloned ${cyan(r.name || r.url)} to ${cyan(relative(process.cwd(), r.dir))}
-`);
-  if (args.shell) {
+  console.log(
+    `\u2728 Successfully cloned ${cyan(r.name || r.url)} to ${cyan(
+      relative(process.cwd(), r.dir)
+    )}
+`
+  );
+  if (arguments_.shell) {
     startShell(r.dir);
   }
   process.exit(0);
 }
-main().catch((err) => {
-  console.error(err);
+main().catch((error) => {
+  console.error(error);
   process.exit(1);
 });

package/dist/index.cjs

@@ -1,18 +1,17 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const giget = require('./shared/giget.3522139c.cjs');
+const giget = require('./shared/giget.51477975.cjs');
 require('node:fs/promises');
-require('node:os');
 require('node:fs');
 require('tar');
 require('pathe');
 require('defu');
 require('node:stream');
 require('node:child_process');
+require('node:os');
 require('node:util');
 require('node-fetch-native');
+require('https-proxy-agent');
 
 
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 interface GitInfo {
-    provider: 'github' | 'gitlab' | 'bitbucket' | 'sourcehut';
+    provider: "github" | "gitlab" | "bitbucket" | "sourcehut";
     repo: string;
     subdir: string;
     ref: string;
@@ -16,7 +16,7 @@ interface TemplateInfo {
     dir?: never;
     [key: string]: any;
 }
-declare type TemplateProvider = (input: string, options: {
+type TemplateProvider = (input: string, options: {
     auth?: string;
 }) => TemplateInfo | Promise<TemplateInfo> | null;
 
@@ -32,13 +32,15 @@ interface DownloadTemplateOptions {
     cwd?: string;
     auth?: string;
 }
-declare type DownloadTemplateResult = Omit<TemplateInfo, 'dir' | 'source'> & {
+type DownloadTemplateResult = Omit<TemplateInfo, "dir" | "source"> & {
     dir: string;
     source: string;
 };
-declare function downloadTemplate(input: string, opts?: DownloadTemplateOptions): Promise<DownloadTemplateResult>;
+declare function downloadTemplate(input: string, options?: DownloadTemplateOptions): Promise<DownloadTemplateResult>;
 
-declare const registryProvider: (registryEndpoint?: string) => TemplateProvider;
+declare const registryProvider: (registryEndpoint?: string, options?: {
+    auth?: string;
+}) => TemplateProvider;
 
 declare function startShell(cwd: string): void;
 

package/dist/index.mjs

@@ -1,11 +1,12 @@
-export { d as downloadTemplate, r as registryProvider, s as startShell } from './shared/giget.dd19862e.mjs';
+export { d as downloadTemplate, r as registryProvider, s as startShell } from './shared/giget.6c52cb03.mjs';
 import 'node:fs/promises';
-import 'node:os';
 import 'node:fs';
 import 'tar';
 import 'pathe';
 import 'defu';
 import 'node:stream';
 import 'node:child_process';
+import 'node:os';
 import 'node:util';
 import 'node-fetch-native';
+import 'https-proxy-agent';

package/dist/shared/giget.51477975.cjs

@@ -0,0 +1,274 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const node_fs = require('node:fs');
+const tar = require('tar');
+const pathe = require('pathe');
+const defu = require('defu');
+const node_stream = require('node:stream');
+const node_child_process = require('node:child_process');
+const node_os = require('node:os');
+const node_util = require('node:util');
+const nodeFetchNative = require('node-fetch-native');
+const createHttpsProxyAgent = require('https-proxy-agent');
+
+async function download(url, filePath, options = {}) {
+  const infoPath = filePath + ".json";
+  const info = JSON.parse(
+    await promises.readFile(infoPath, "utf8").catch(() => "{}")
+  );
+  const headResponse = await sendFetch(url, {
+    method: "HEAD",
+    headers: options.headers
+  }).catch(() => void 0);
+  const etag = headResponse?.headers.get("etag");
+  if (info.etag === etag && node_fs.existsSync(filePath)) {
+    return;
+  }
+  info.etag = etag;
+  const response = await sendFetch(url, { headers: options.headers });
+  if (response.status >= 400) {
+    throw new Error(
+      `Failed to download ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const stream = node_fs.createWriteStream(filePath);
+  await node_util.promisify(node_stream.pipeline)(response.body, stream);
+  await promises.writeFile(infoPath, JSON.stringify(info), "utf8");
+}
+const inputRegex = /^(?<repo>[\w.-]+\/[\w.-]+)(?<subdir>[^#]+)?(?<ref>#[\w.-]+)?/;
+function parseGitURI(input) {
+  const m = input.match(inputRegex)?.groups;
+  return {
+    repo: m.repo,
+    subdir: m.subdir || "/",
+    ref: m.ref ? m.ref.slice(1) : "main"
+  };
+}
+function debug(...arguments_) {
+  if (process.env.DEBUG) {
+    console.debug("[giget]", ...arguments_);
+  }
+}
+async function sendFetch(url, options) {
+  const proxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  const requestOptions = proxy ? { agent: createHttpsProxyAgent(proxy), ...options } : options;
+  return await nodeFetchNative.fetch(url, requestOptions);
+}
+function cacheDirectory() {
+  return process.env.XDG_CACHE_HOME ? pathe.resolve(process.env.XDG_CACHE_HOME, "giget") : pathe.resolve(node_os.homedir(), ".cache/giget");
+}
+function currentShell() {
+  if (process.env.SHELL) {
+    return process.env.SHELL;
+  }
+  if (process.platform === "win32") {
+    return "cmd.exe";
+  }
+  return "/bin/bash";
+}
+function startShell(cwd) {
+  cwd = pathe.resolve(cwd);
+  const shell = currentShell();
+  console.info(
+    `(experimental) Opening shell in ${pathe.relative(process.cwd(), cwd)}...`
+  );
+  node_child_process.spawnSync(shell, [], {
+    cwd,
+    shell: true,
+    stdio: "inherit"
+  });
+}
+
+const github = (input, options) => {
+  const parsed = parseGitURI(input);
+  const github2 = process.env.GIGET_GITHUB_URL || "https://github.com";
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `${github2}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+    tar: `${github2}/${parsed.repo}/archive/${parsed.ref}.tar.gz`
+  };
+};
+const gitlab = (input, options) => {
+  const parsed = parseGitURI(input);
+  const gitlab2 = process.env.GIGET_GITLAB_URL || "https://gitlab.com";
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `${gitlab2}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+    tar: `${gitlab2}/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
+  };
+};
+const bitbucket = (input, options) => {
+  const parsed = parseGitURI(input);
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
+    tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
+  };
+};
+const sourcehut = (input, options) => {
+  const parsed = parseGitURI(input);
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
+    tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
+  };
+};
+const providers = {
+  github,
+  gh: github,
+  gitlab,
+  bitbucket,
+  sourcehut
+};
+
+const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
+const registryProvider = (registryEndpoint = DEFAULT_REGISTRY, options) => {
+  options = options || {};
+  return async (input) => {
+    const start = Date.now();
+    const registryURL = `${registryEndpoint}/${input}.json`;
+    const result = await sendFetch(registryURL, {
+      headers: {
+        Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+      }
+    });
+    if (result.status >= 400) {
+      throw new Error(
+        `Failed to download ${input} template info from ${registryURL}: ${result.status} ${result.statusText}`
+      );
+    }
+    const info = await result.json();
+    if (!info.tar || !info.name) {
+      throw new Error(
+        `Invalid template info from ${registryURL}. name or tar fields are missing!`
+      );
+    }
+    debug(
+      `Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`
+    );
+    return info;
+  };
+};
+
+const sourceProtoRe = /^([\w-.]+):/;
+async function downloadTemplate(input, options = {}) {
+  options = defu.defu(
+    {
+      registry: process.env.GIGET_REGISTRY,
+      auth: process.env.GIGET_AUTH
+    },
+    options
+  );
+  const registry = options.registry !== false ? registryProvider(options.registry, { auth: options.auth }) : void 0;
+  let providerName = options.provider || (registryProvider ? "registry" : "github");
+  let source = input;
+  const sourceProvierMatch = input.match(sourceProtoRe);
+  if (sourceProvierMatch) {
+    providerName = sourceProvierMatch[1];
+    source = input.slice(sourceProvierMatch[0].length);
+  }
+  const provider = options.providers?.[providerName] || providers[providerName] || registry;
+  if (!provider) {
+    throw new Error(`Unsupported provider: ${providerName}`);
+  }
+  const template = await Promise.resolve().then(() => provider(source, { auth: options.auth })).catch((error) => {
+    throw new Error(
+      `Failed to download template from ${providerName}: ${error.message}`
+    );
+  });
+  template.name = (template.name || "template").replace(/[^\da-z-]/gi, "-");
+  template.defaultDir = (template.defaultDir || template.name).replace(
+    /[^\da-z-]/gi,
+    "-"
+  );
+  const cwd = pathe.resolve(options.cwd || ".");
+  const extractPath = pathe.resolve(cwd, options.dir || template.defaultDir);
+  if (options.forceClean) {
+    await promises.rm(extractPath, { recursive: true, force: true });
+  }
+  if (!options.force && node_fs.existsSync(extractPath) && node_fs.readdirSync(extractPath).length > 0) {
+    throw new Error(`Destination ${extractPath} already exists.`);
+  }
+  await promises.mkdir(extractPath, { recursive: true });
+  const temporaryDirectory = pathe.resolve(
+    cacheDirectory(),
+    options.provider,
+    template.name
+  );
+  const tarPath = pathe.resolve(
+    temporaryDirectory,
+    (template.version || template.name) + ".tar.gz"
+  );
+  if (options.preferOffline && node_fs.existsSync(tarPath)) {
+    options.offline = true;
+  }
+  if (!options.offline) {
+    await promises.mkdir(pathe.dirname(tarPath), { recursive: true });
+    const s2 = Date.now();
+    await download(template.tar, tarPath, {
+      headers: {
+        authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+        ...template.headers
+      }
+    }).catch((error) => {
+      if (!node_fs.existsSync(tarPath)) {
+        throw error;
+      }
+      debug("Download error. Using cached version:", error);
+      options.offline = true;
+    });
+    debug(`Downloaded ${template.tar} to ${tarPath} in ${Date.now() - s2}ms`);
+  }
+  if (!node_fs.existsSync(tarPath)) {
+    throw new Error(
+      `Tarball not found: ${tarPath} (offline: ${options.offline})`
+    );
+  }
+  const s = Date.now();
+  const subdir = template.subdir?.replace(/^\//, "") || "";
+  await tar.extract({
+    file: tarPath,
+    cwd: extractPath,
+    onentry(entry) {
+      entry.path = entry.path.split("/").splice(1).join("/");
+      if (subdir) {
+        if (entry.path.startsWith(subdir + "/")) {
+          entry.path = entry.path.slice(subdir.length);
+        } else {
+          entry.path = "";
+        }
+      }
+    }
+  });
+  debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
+  return {
+    ...template,
+    source,
+    dir: extractPath
+  };
+}
+
+exports.downloadTemplate = downloadTemplate;
+exports.registryProvider = registryProvider;
+exports.startShell = startShell;

package/dist/shared/giget.6c52cb03.mjs

@@ -0,0 +1,270 @@
+import { readFile, writeFile, rm, mkdir } from 'node:fs/promises';
+import { existsSync, createWriteStream, readdirSync } from 'node:fs';
+import { extract } from 'tar';
+import { resolve, relative, dirname } from 'pathe';
+import { defu } from 'defu';
+import { pipeline } from 'node:stream';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { promisify } from 'node:util';
+import { fetch } from 'node-fetch-native';
+import createHttpsProxyAgent from 'https-proxy-agent';
+
+async function download(url, filePath, options = {}) {
+  const infoPath = filePath + ".json";
+  const info = JSON.parse(
+    await readFile(infoPath, "utf8").catch(() => "{}")
+  );
+  const headResponse = await sendFetch(url, {
+    method: "HEAD",
+    headers: options.headers
+  }).catch(() => void 0);
+  const etag = headResponse?.headers.get("etag");
+  if (info.etag === etag && existsSync(filePath)) {
+    return;
+  }
+  info.etag = etag;
+  const response = await sendFetch(url, { headers: options.headers });
+  if (response.status >= 400) {
+    throw new Error(
+      `Failed to download ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const stream = createWriteStream(filePath);
+  await promisify(pipeline)(response.body, stream);
+  await writeFile(infoPath, JSON.stringify(info), "utf8");
+}
+const inputRegex = /^(?<repo>[\w.-]+\/[\w.-]+)(?<subdir>[^#]+)?(?<ref>#[\w.-]+)?/;
+function parseGitURI(input) {
+  const m = input.match(inputRegex)?.groups;
+  return {
+    repo: m.repo,
+    subdir: m.subdir || "/",
+    ref: m.ref ? m.ref.slice(1) : "main"
+  };
+}
+function debug(...arguments_) {
+  if (process.env.DEBUG) {
+    console.debug("[giget]", ...arguments_);
+  }
+}
+async function sendFetch(url, options) {
+  const proxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  const requestOptions = proxy ? { agent: createHttpsProxyAgent(proxy), ...options } : options;
+  return await fetch(url, requestOptions);
+}
+function cacheDirectory() {
+  return process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "giget") : resolve(homedir(), ".cache/giget");
+}
+function currentShell() {
+  if (process.env.SHELL) {
+    return process.env.SHELL;
+  }
+  if (process.platform === "win32") {
+    return "cmd.exe";
+  }
+  return "/bin/bash";
+}
+function startShell(cwd) {
+  cwd = resolve(cwd);
+  const shell = currentShell();
+  console.info(
+    `(experimental) Opening shell in ${relative(process.cwd(), cwd)}...`
+  );
+  spawnSync(shell, [], {
+    cwd,
+    shell: true,
+    stdio: "inherit"
+  });
+}
+
+const github = (input, options) => {
+  const parsed = parseGitURI(input);
+  const github2 = process.env.GIGET_GITHUB_URL || "https://github.com";
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `${github2}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+    tar: `${github2}/${parsed.repo}/archive/${parsed.ref}.tar.gz`
+  };
+};
+const gitlab = (input, options) => {
+  const parsed = parseGitURI(input);
+  const gitlab2 = process.env.GIGET_GITLAB_URL || "https://gitlab.com";
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `${gitlab2}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+    tar: `${gitlab2}/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
+  };
+};
+const bitbucket = (input, options) => {
+  const parsed = parseGitURI(input);
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
+    tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
+  };
+};
+const sourcehut = (input, options) => {
+  const parsed = parseGitURI(input);
+  return {
+    name: parsed.repo.replace("/", "-"),
+    version: parsed.ref,
+    subdir: parsed.subdir,
+    headers: {
+      Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+    },
+    url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
+    tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
+  };
+};
+const providers = {
+  github,
+  gh: github,
+  gitlab,
+  bitbucket,
+  sourcehut
+};
+
+const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
+const registryProvider = (registryEndpoint = DEFAULT_REGISTRY, options) => {
+  options = options || {};
+  return async (input) => {
+    const start = Date.now();
+    const registryURL = `${registryEndpoint}/${input}.json`;
+    const result = await sendFetch(registryURL, {
+      headers: {
+        Authorization: options.auth ? `Bearer ${options.auth}` : void 0
+      }
+    });
+    if (result.status >= 400) {
+      throw new Error(
+        `Failed to download ${input} template info from ${registryURL}: ${result.status} ${result.statusText}`
+      );
+    }
+    const info = await result.json();
+    if (!info.tar || !info.name) {
+      throw new Error(
+        `Invalid template info from ${registryURL}. name or tar fields are missing!`
+      );
+    }
+    debug(
+      `Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`
+    );
+    return info;
+  };
+};
+
+const sourceProtoRe = /^([\w-.]+):/;
+async function downloadTemplate(input, options = {}) {
+  options = defu(
+    {
+      registry: process.env.GIGET_REGISTRY,
+      auth: process.env.GIGET_AUTH
+    },
+    options
+  );
+  const registry = options.registry !== false ? registryProvider(options.registry, { auth: options.auth }) : void 0;
+  let providerName = options.provider || (registryProvider ? "registry" : "github");
+  let source = input;
+  const sourceProvierMatch = input.match(sourceProtoRe);
+  if (sourceProvierMatch) {
+    providerName = sourceProvierMatch[1];
+    source = input.slice(sourceProvierMatch[0].length);
+  }
+  const provider = options.providers?.[providerName] || providers[providerName] || registry;
+  if (!provider) {
+    throw new Error(`Unsupported provider: ${providerName}`);
+  }
+  const template = await Promise.resolve().then(() => provider(source, { auth: options.auth })).catch((error) => {
+    throw new Error(
+      `Failed to download template from ${providerName}: ${error.message}`
+    );
+  });
+  template.name = (template.name || "template").replace(/[^\da-z-]/gi, "-");
+  template.defaultDir = (template.defaultDir || template.name).replace(
+    /[^\da-z-]/gi,
+    "-"
+  );
+  const cwd = resolve(options.cwd || ".");
+  const extractPath = resolve(cwd, options.dir || template.defaultDir);
+  if (options.forceClean) {
+    await rm(extractPath, { recursive: true, force: true });
+  }
+  if (!options.force && existsSync(extractPath) && readdirSync(extractPath).length > 0) {
+    throw new Error(`Destination ${extractPath} already exists.`);
+  }
+  await mkdir(extractPath, { recursive: true });
+  const temporaryDirectory = resolve(
+    cacheDirectory(),
+    options.provider,
+    template.name
+  );
+  const tarPath = resolve(
+    temporaryDirectory,
+    (template.version || template.name) + ".tar.gz"
+  );
+  if (options.preferOffline && existsSync(tarPath)) {
+    options.offline = true;
+  }
+  if (!options.offline) {
+    await mkdir(dirname(tarPath), { recursive: true });
+    const s2 = Date.now();
+    await download(template.tar, tarPath, {
+      headers: {
+        authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+        ...template.headers
+      }
+    }).catch((error) => {
+      if (!existsSync(tarPath)) {
+        throw error;
+      }
+      debug("Download error. Using cached version:", error);
+      options.offline = true;
+    });
+    debug(`Downloaded ${template.tar} to ${tarPath} in ${Date.now() - s2}ms`);
+  }
+  if (!existsSync(tarPath)) {
+    throw new Error(
+      `Tarball not found: ${tarPath} (offline: ${options.offline})`
+    );
+  }
+  const s = Date.now();
+  const subdir = template.subdir?.replace(/^\//, "") || "";
+  await extract({
+    file: tarPath,
+    cwd: extractPath,
+    onentry(entry) {
+      entry.path = entry.path.split("/").splice(1).join("/");
+      if (subdir) {
+        if (entry.path.startsWith(subdir + "/")) {
+          entry.path = entry.path.slice(subdir.length);
+        } else {
+          entry.path = "";
+        }
+      }
+    }
+  });
+  debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
+  return {
+    ...template,
+    source,
+    dir: extractPath
+  };
+}
+
+export { downloadTemplate as d, registryProvider as r, startShell as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "giget",
-  "version": "0.1.7",
+  "version": "1.1.0",
   "description": "Download templates and git repositories with pleasure!",
   "repository": "unjs/giget",
   "license": "MIT",
@@ -12,6 +12,7 @@
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts",
       "require": "./dist/index.cjs"
     }
   },
@@ -21,34 +22,38 @@
   "files": [
     "dist"
   ],
-  "dependencies": {
-    "colorette": "^2.0.19",
-    "defu": "^6.1.0",
-    "mri": "^1.2.0",
-    "node-fetch-native": "^0.1.4",
-    "pathe": "^0.3.8",
-    "tar": "^6.1.11"
-  },
-  "devDependencies": {
-    "@nuxtjs/eslint-config-typescript": "^11.0.0",
-    "@types/node": "^18.7.16",
-    "@types/tar": "^6.1.2",
-    "@vitest/coverage-c8": "^0.23.4",
-    "eslint": "^8.23.1",
-    "jiti": "^1.16.0",
-    "standard-version": "^9.5.0",
-    "typescript": "^4.8.3",
-    "unbuild": "^0.8.11",
-    "vitest": "^0.23.4"
-  },
-  "packageManager": "pnpm@7.12.0",
   "scripts": {
     "build": "unbuild",
     "dev": "vitest dev",
     "giget": "jiti ./src/cli.ts",
-    "lint": "eslint --ext .ts,.js,.mjs,.cjs .",
+    "lint": "eslint --ext .ts,.js,.mjs,.cjs . && prettier -c src test",
+    "lint:fix": "eslint --ext .ts,.js,.mjs,.cjs . --fix && prettier -w src test",
+    "prepack": "unbuild",
     "play": "pnpm giget --force-clean --verbose unjs .tmp/clone",
-    "release": "pnpm test && standard-version && git push --follow-tags && pnpm publish",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
     "test": "pnpm lint && vitest run --coverage"
-  }
-}
+  },
+  "dependencies": {
+    "colorette": "^2.0.19",
+    "defu": "^6.1.2",
+    "https-proxy-agent": "^5.0.1",
+    "mri": "^1.2.0",
+    "node-fetch-native": "^1.0.2",
+    "pathe": "^1.1.0",
+    "tar": "^6.1.13"
+  },
+  "devDependencies": {
+    "@types/node": "^18.13.0",
+    "@types/tar": "^6.1.4",
+    "@vitest/coverage-c8": "^0.28.5",
+    "changelogen": "^0.4.1",
+    "eslint": "^8.34.0",
+    "eslint-config-unjs": "^0.1.0",
+    "jiti": "^1.17.0",
+    "prettier": "^2.8.4",
+    "typescript": "^4.9.5",
+    "unbuild": "^1.1.1",
+    "vitest": "^0.28.5"
+  },
+  "packageManager": "pnpm@7.27.0"
+}

package/dist/shared/giget.3522139c.cjs

@@ -1,217 +0,0 @@
-'use strict';
-
-const promises = require('node:fs/promises');
-const node_os = require('node:os');
-const node_fs = require('node:fs');
-const tar = require('tar');
-const pathe = require('pathe');
-const defu = require('defu');
-const node_stream = require('node:stream');
-const node_child_process = require('node:child_process');
-const node_util = require('node:util');
-const fetch = require('node-fetch-native');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-const fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
-
-async function download(url, filePath, opts = {}) {
-  const infoPath = filePath + ".json";
-  const info = JSON.parse(await promises.readFile(infoPath, "utf8").catch(() => "{}"));
-  const headRes = await fetch.fetch(url, { method: "HEAD", headers: opts.headers }).catch(() => null);
-  const etag = headRes?.headers.get("etag");
-  if (info.etag === etag && node_fs.existsSync(filePath)) {
-    return;
-  }
-  info.etag = etag;
-  const res = await fetch.fetch(url, { headers: opts.headers });
-  if (res.status >= 400) {
-    throw new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
-  }
-  const stream = node_fs.createWriteStream(filePath);
-  await node_util.promisify(node_stream.pipeline)(res.body, stream);
-  await promises.writeFile(infoPath, JSON.stringify(info), "utf8");
-}
-const inputRegex = /^(?<repo>[\w.-]+\/[\w.-]+)(?<subdir>[^#]+)?(?<ref>#[\w.-]+)?/;
-function parseGitURI(input) {
-  const m = input.match(inputRegex)?.groups;
-  return {
-    repo: m.repo,
-    subdir: m.subdir || "/",
-    ref: m.ref ? m.ref.substring(1) : "main"
-  };
-}
-function debug(...args) {
-  if (process.env.DEBUG) {
-    console.debug("[giget]", ...args);
-  }
-}
-function currentShell() {
-  if (process.env.SHELL) {
-    return process.env.SHELL;
-  }
-  if (process.platform === "win32") {
-    return "cmd.exe";
-  }
-  return "/bin/bash";
-}
-function startShell(cwd) {
-  cwd = pathe.resolve(cwd);
-  const shell = currentShell();
-  console.info(`(experimental) Opening shell in ${pathe.relative(process.cwd(), cwd)}...`);
-  node_child_process.spawnSync(shell, [], {
-    cwd,
-    shell: true,
-    stdio: "inherit"
-  });
-}
-
-const github = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://github.com/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
-    tar: `https://github.com/${parsed.repo}/archive/${parsed.ref}.tar.gz`
-  };
-};
-const gitlab = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://gitlab.com/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
-    tar: `https://gitlab.com/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
-  };
-};
-const bitbucket = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
-    tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
-  };
-};
-const sourcehut = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
-    tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
-  };
-};
-const providers = {
-  github,
-  gh: github,
-  gitlab,
-  bitbucket,
-  sourcehut
-};
-
-const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
-const registryProvider = (registryEndpoint = DEFAULT_REGISTRY) => {
-  return async (input) => {
-    const start = Date.now();
-    const registryURL = `${registryEndpoint}/${input}.json`;
-    const res = await fetch__default(registryURL);
-    if (res.status >= 400) {
-      throw new Error(`Failed to download ${input} template info from ${registryURL}: ${res.status} ${res.statusText}`);
-    }
-    const info = await res.json();
-    if (!info.tar || !info.name) {
-      throw new Error(`Invalid template info from ${registryURL}. name or tar fields are missing!`);
-    }
-    debug(`Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`);
-    return info;
-  };
-};
-
-const sourceProtoRe = /^([\w-.]+):/;
-async function downloadTemplate(input, opts = {}) {
-  opts = defu.defu({
-    registry: process.env.GIGET_REGISTRY,
-    auth: process.env.GIGET_AUTH
-  }, opts);
-  const registry = opts.registry !== false ? registryProvider(opts.registry) : null;
-  let providerName = opts.provider || (registryProvider ? "registry" : "github");
-  let source = input;
-  const sourceProvierMatch = input.match(sourceProtoRe);
-  if (sourceProvierMatch) {
-    providerName = sourceProvierMatch[1];
-    source = input.substring(sourceProvierMatch[0].length);
-  }
-  const provider = opts.providers?.[providerName] || providers[providerName] || registry;
-  if (!provider) {
-    throw new Error(`Unsupported provider: ${providerName}`);
-  }
-  const template = await Promise.resolve().then(() => provider(source, { auth: opts.auth })).catch((err) => {
-    throw new Error(`Failed to download template from ${providerName}: ${err.message}`);
-  });
-  template.name = (template.name || "template").replace(/[^a-z0-9-]/gi, "-");
-  template.defaultDir = (template.defaultDir || template.name).replace(/[^a-z0-9-]/gi, "-");
-  const cwd = pathe.resolve(opts.cwd || ".");
-  const extractPath = pathe.resolve(cwd, opts.dir || template.defaultDir);
-  if (opts.forceClean) {
-    await promises.rm(extractPath, { recursive: true, force: true });
-  }
-  if (!opts.force && node_fs.existsSync(extractPath) && node_fs.readdirSync(extractPath).length) {
-    throw new Error(`Destination ${extractPath} already exists.`);
-  }
-  await promises.mkdir(extractPath, { recursive: true });
-  const tmpDir = pathe.resolve(node_os.homedir(), ".giget", opts.provider, template.name);
-  const tarPath = pathe.resolve(tmpDir, (template.version || template.name) + ".tar.gz");
-  if (opts.preferOffline && node_fs.existsSync(tarPath)) {
-    opts.offline = true;
-  }
-  if (!opts.offline) {
-    await promises.mkdir(pathe.dirname(tarPath), { recursive: true });
-    const s2 = Date.now();
-    await download(template.tar, tarPath, { headers: template.headers }).catch((err) => {
-      if (!node_fs.existsSync(tarPath)) {
-        throw err;
-      }
-      debug("Download error. Using cached version:", err);
-      opts.offline = true;
-    });
-    debug(`Downloaded ${template.tar} to ${tarPath} in ${Date.now() - s2}ms`);
-  }
-  if (!node_fs.existsSync(tarPath)) {
-    throw new Error(`Tarball not found: ${tarPath} (offline: ${opts.offline})`);
-  }
-  const s = Date.now();
-  const subdir = template.subdir?.replace(/^\//, "") || "";
-  await tar.extract({
-    file: tarPath,
-    cwd: extractPath,
-    onentry(entry) {
-      entry.path = entry.path.split("/").splice(1).join("/");
-      if (subdir) {
-        if (entry.path.startsWith(subdir + "/")) {
-          entry.path = entry.path.substring(subdir.length);
-        } else {
-          entry.path = "";
-        }
-      }
-    }
-  });
-  debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
-  return {
-    ...template,
-    source,
-    dir: extractPath
-  };
-}
-
-exports.downloadTemplate = downloadTemplate;
-exports.registryProvider = registryProvider;
-exports.startShell = startShell;

package/dist/shared/giget.dd19862e.mjs

@@ -1,209 +0,0 @@
-import { readFile, writeFile, rm, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { existsSync, createWriteStream, readdirSync } from 'node:fs';
-import { extract } from 'tar';
-import { resolve, relative, dirname } from 'pathe';
-import { defu } from 'defu';
-import { pipeline } from 'node:stream';
-import { spawnSync } from 'node:child_process';
-import { promisify } from 'node:util';
-import fetch$1, { fetch } from 'node-fetch-native';
-
-async function download(url, filePath, opts = {}) {
-  const infoPath = filePath + ".json";
-  const info = JSON.parse(await readFile(infoPath, "utf8").catch(() => "{}"));
-  const headRes = await fetch(url, { method: "HEAD", headers: opts.headers }).catch(() => null);
-  const etag = headRes?.headers.get("etag");
-  if (info.etag === etag && existsSync(filePath)) {
-    return;
-  }
-  info.etag = etag;
-  const res = await fetch(url, { headers: opts.headers });
-  if (res.status >= 400) {
-    throw new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
-  }
-  const stream = createWriteStream(filePath);
-  await promisify(pipeline)(res.body, stream);
-  await writeFile(infoPath, JSON.stringify(info), "utf8");
-}
-const inputRegex = /^(?<repo>[\w.-]+\/[\w.-]+)(?<subdir>[^#]+)?(?<ref>#[\w.-]+)?/;
-function parseGitURI(input) {
-  const m = input.match(inputRegex)?.groups;
-  return {
-    repo: m.repo,
-    subdir: m.subdir || "/",
-    ref: m.ref ? m.ref.substring(1) : "main"
-  };
-}
-function debug(...args) {
-  if (process.env.DEBUG) {
-    console.debug("[giget]", ...args);
-  }
-}
-function currentShell() {
-  if (process.env.SHELL) {
-    return process.env.SHELL;
-  }
-  if (process.platform === "win32") {
-    return "cmd.exe";
-  }
-  return "/bin/bash";
-}
-function startShell(cwd) {
-  cwd = resolve(cwd);
-  const shell = currentShell();
-  console.info(`(experimental) Opening shell in ${relative(process.cwd(), cwd)}...`);
-  spawnSync(shell, [], {
-    cwd,
-    shell: true,
-    stdio: "inherit"
-  });
-}
-
-const github = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://github.com/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
-    tar: `https://github.com/${parsed.repo}/archive/${parsed.ref}.tar.gz`
-  };
-};
-const gitlab = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://gitlab.com/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
-    tar: `https://gitlab.com/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
-  };
-};
-const bitbucket = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
-    tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
-  };
-};
-const sourcehut = (input, opts) => {
-  const parsed = parseGitURI(input);
-  return {
-    name: parsed.repo.replace("/", "-"),
-    version: parsed.ref,
-    subdir: parsed.subdir,
-    headers: { Authorization: opts.auth ? `Bearer ${opts.auth}` : void 0 },
-    url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
-    tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
-  };
-};
-const providers = {
-  github,
-  gh: github,
-  gitlab,
-  bitbucket,
-  sourcehut
-};
-
-const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
-const registryProvider = (registryEndpoint = DEFAULT_REGISTRY) => {
-  return async (input) => {
-    const start = Date.now();
-    const registryURL = `${registryEndpoint}/${input}.json`;
-    const res = await fetch$1(registryURL);
-    if (res.status >= 400) {
-      throw new Error(`Failed to download ${input} template info from ${registryURL}: ${res.status} ${res.statusText}`);
-    }
-    const info = await res.json();
-    if (!info.tar || !info.name) {
-      throw new Error(`Invalid template info from ${registryURL}. name or tar fields are missing!`);
-    }
-    debug(`Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`);
-    return info;
-  };
-};
-
-const sourceProtoRe = /^([\w-.]+):/;
-async function downloadTemplate(input, opts = {}) {
-  opts = defu({
-    registry: process.env.GIGET_REGISTRY,
-    auth: process.env.GIGET_AUTH
-  }, opts);
-  const registry = opts.registry !== false ? registryProvider(opts.registry) : null;
-  let providerName = opts.provider || (registryProvider ? "registry" : "github");
-  let source = input;
-  const sourceProvierMatch = input.match(sourceProtoRe);
-  if (sourceProvierMatch) {
-    providerName = sourceProvierMatch[1];
-    source = input.substring(sourceProvierMatch[0].length);
-  }
-  const provider = opts.providers?.[providerName] || providers[providerName] || registry;
-  if (!provider) {
-    throw new Error(`Unsupported provider: ${providerName}`);
-  }
-  const template = await Promise.resolve().then(() => provider(source, { auth: opts.auth })).catch((err) => {
-    throw new Error(`Failed to download template from ${providerName}: ${err.message}`);
-  });
-  template.name = (template.name || "template").replace(/[^a-z0-9-]/gi, "-");
-  template.defaultDir = (template.defaultDir || template.name).replace(/[^a-z0-9-]/gi, "-");
-  const cwd = resolve(opts.cwd || ".");
-  const extractPath = resolve(cwd, opts.dir || template.defaultDir);
-  if (opts.forceClean) {
-    await rm(extractPath, { recursive: true, force: true });
-  }
-  if (!opts.force && existsSync(extractPath) && readdirSync(extractPath).length) {
-    throw new Error(`Destination ${extractPath} already exists.`);
-  }
-  await mkdir(extractPath, { recursive: true });
-  const tmpDir = resolve(homedir(), ".giget", opts.provider, template.name);
-  const tarPath = resolve(tmpDir, (template.version || template.name) + ".tar.gz");
-  if (opts.preferOffline && existsSync(tarPath)) {
-    opts.offline = true;
-  }
-  if (!opts.offline) {
-    await mkdir(dirname(tarPath), { recursive: true });
-    const s2 = Date.now();
-    await download(template.tar, tarPath, { headers: template.headers }).catch((err) => {
-      if (!existsSync(tarPath)) {
-        throw err;
-      }
-      debug("Download error. Using cached version:", err);
-      opts.offline = true;
-    });
-    debug(`Downloaded ${template.tar} to ${tarPath} in ${Date.now() - s2}ms`);
-  }
-  if (!existsSync(tarPath)) {
-    throw new Error(`Tarball not found: ${tarPath} (offline: ${opts.offline})`);
-  }
-  const s = Date.now();
-  const subdir = template.subdir?.replace(/^\//, "") || "";
-  await extract({
-    file: tarPath,
-    cwd: extractPath,
-    onentry(entry) {
-      entry.path = entry.path.split("/").splice(1).join("/");
-      if (subdir) {
-        if (entry.path.startsWith(subdir + "/")) {
-          entry.path = entry.path.substring(subdir.length);
-        } else {
-          entry.path = "";
-        }
-      }
-    }
-  });
-  debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
-  return {
-    ...template,
-    source,
-    dir: extractPath
-  };
-}
-
-export { downloadTemplate as d, registryProvider as r, startShell as s };