@decaf-ts/utils 0.1.6

package/lib/utils/fs.cjs

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFile = patchFile;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.getPackage = getPackage;
+exports.setPackageAttribute = setPackageAttribute;
+exports.getPackageVersion = getPackageVersion;
+exports.getDependencies = getDependencies;
+exports.updateDependencies = updateDependencies;
+exports.installIfNotAvailable = installIfNotAvailable;
+exports.pushToGit = pushToGit;
+exports.installDependencies = installDependencies;
+exports.normalizeImport = normalizeImport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logging_1 = require("../output/logging.cjs");
+const text_1 = require("./text.cjs");
+const utils_1 = require("./utils.cjs");
+const logger = logging_1.Logging.for("fs");
+/**
+ * @description Patches a file with given values.
+ * @summary Reads a file, applies patches using TextUtils, and writes the result back to the file.
+ *
+ * @param {string} path - The path to the file to be patched.
+ * @param {Record<string, number | string>} values - The values to patch into the file.
+ * @return {void}
+ *
+ * @function patchFile
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant patchFile
+ *   participant fs
+ *   participant readFile
+ *   participant TextUtils
+ *   participant writeFile
+ *   Caller->>patchFile: Call with path and values
+ *   patchFile->>fs: Check if file exists
+ *   patchFile->>readFile: Read file content
+ *   readFile->>fs: Read file
+ *   fs-->>readFile: Return file content
+ *   readFile-->>patchFile: Return file content
+ *   patchFile->>TextUtils: Patch string
+ *   TextUtils-->>patchFile: Return patched content
+ *   patchFile->>writeFile: Write patched content
+ *   writeFile->>fs: Write to file
+ *   fs-->>writeFile: File written
+ *   writeFile-->>patchFile: File written
+ *   patchFile-->>Caller: Patching complete
+ *
+ * @memberOf module:fs-utils
+ */
+function patchFile(path, values) {
+    const log = logger.for(patchFile);
+    if (!fs_1.default.existsSync(path))
+        throw new Error(`File not found at path "${path}".`);
+    let content = readFile(path);
+    try {
+        log.verbose(`Patching file "${path}"...`);
+        log.debug(`with value: ${JSON.stringify(values)}`);
+        content = (0, text_1.patchString)(content, values);
+    }
+    catch (error) {
+        throw new Error(`Error patching file: ${error}`);
+    }
+    writeFile(path, content);
+}
+/**
+ * @description Reads a file and returns its content.
+ * @summary Reads the content of a file at the specified path and returns it as a string.
+ *
+ * @param {string} path - The path to the file to be read.
+ * @return {string} The content of the file.
+ *
+ * @function readFile
+ *
+ * @memberOf module:utils
+ */
+function readFile(path) {
+    const log = logger.for(readFile);
+    try {
+        log.verbose(`Reading file "${path}"...`);
+        return fs_1.default.readFileSync(path, "utf8");
+    }
+    catch (error) {
+        log.verbose(`Error reading file "${path}": ${error}`);
+        throw new Error(`Error reading file "${path}": ${error}`);
+    }
+}
+/**
+ * @description Writes data to a file.
+ * @summary Writes the provided data to a file at the specified path.
+ *
+ * @param {string} path - The path to the file to be written.
+ * @param {string | Buffer} data - The data to be written to the file.
+ * @return {void}
+ *
+ * @function writeFile
+ *
+ * @memberOf module:utils
+ */
+function writeFile(path, data) {
+    const log = logger.for(writeFile);
+    try {
+        log.verbose(`Writing file "${path} with ${data.length} bytes...`);
+        fs_1.default.writeFileSync(path, data, "utf8");
+    }
+    catch (error) {
+        log.verbose(`Error writing file "${path}": ${error}`);
+        throw new Error(`Error writing file "${path}": ${error}`);
+    }
+}
+/**
+ * @description Retrieves package information from package.json.
+ * @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.
+ * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.
+ * @param {string} [property] - Optional. The specific property to retrieve from package.json.
+ * @return {object | string} The parsed contents of package.json or the value of the specified property.
+ * @function getPackage
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant getPackage
+ *   participant readFile
+ *   participant JSON
+ *   Caller->>getPackage: Call with path and optional property
+ *   getPackage->>readFile: Read package.json
+ *   readFile-->>getPackage: Return file content
+ *   getPackage->>JSON: Parse file content
+ *   JSON-->>getPackage: Return parsed object
+ *   alt property specified
+ *     getPackage->>getPackage: Check if property exists
+ *     alt property exists
+ *       getPackage-->>Caller: Return property value
+ *     else property doesn't exist
+ *       getPackage-->>Caller: Throw Error
+ *     end
+ *   else no property specified
+ *     getPackage-->>Caller: Return entire package object
+ *   end
+ * @memberOf module:utils
+ */
+function getPackage(p = process.cwd(), property) {
+    let pkg;
+    try {
+        pkg = JSON.parse(readFile(path_1.default.join(p, `package.json`)));
+    }
+    catch (error) {
+        throw new Error(`Failed to retrieve package information" ${error}`);
+    }
+    if (property) {
+        if (!(property in pkg))
+            throw new Error(`Property "${property}" not found in package.json`);
+        return pkg[property];
+    }
+    return pkg;
+}
+function setPackageAttribute(attr, value, p = process.cwd()) {
+    const pkg = getPackage(p);
+    pkg[attr] = value;
+    writeFile(path_1.default.join(p, `package.json`), JSON.stringify(pkg, null, 2));
+}
+/**
+ * @description Retrieves the version from package.json.
+ * @summary A convenience function that calls getPackage to retrieve the "version" property from package.json.
+ * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.
+ * @return {string} The version string from package.json.
+ * @function getPackageVersion
+ * @memberOf module:fs-utils
+ */
+function getPackageVersion(p = process.cwd()) {
+    return getPackage(p, "version");
+}
+/**
+ * @description Retrieves all dependencies from the project.
+ * @summary Executes 'npm ls --json' command to get a detailed list of all dependencies (production, development, and peer) and their versions.
+ * @param {string} [path=process.cwd()] - The directory path of the project.
+ * @return {Promise<{prod: Array<{name: string, version: string}>, dev: Array<{name: string, version: string}>, peer: Array<{name: string, version: string}>}>} An object containing arrays of production, development, and peer dependencies.
+ * @function getDependencies
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant getDependencies
+ *   participant runCommand
+ *   participant JSON
+ *   Caller->>getDependencies: Call with optional path
+ *   getDependencies->>runCommand: Execute 'npm ls --json'
+ *   runCommand-->>getDependencies: Return command output
+ *   getDependencies->>JSON: Parse command output
+ *   JSON-->>getDependencies: Return parsed object
+ *   getDependencies->>getDependencies: Process dependencies
+ *   getDependencies-->>Caller: Return processed dependencies
+ * @memberOf module:fs-utils
+ */
+async function getDependencies(path = process.cwd()) {
+    let pkg;
+    try {
+        pkg = JSON.parse(await (0, utils_1.runCommand)(`npm ls --json`, { cwd: path }).promise);
+    }
+    catch (e) {
+        throw new Error(`Failed to retrieve dependencies: ${e}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const mapper = (entry, index) => ({
+        name: entry[0],
+        version: entry[1].version,
+    });
+    return {
+        prod: Object.entries(pkg.dependencies || {}).map(mapper),
+        dev: Object.entries(pkg.devDependencies || {}).map(mapper),
+        peer: Object.entries(pkg.peerDependencies || {}).map(mapper),
+    };
+}
+async function updateDependencies() {
+    const log = logger.for(updateDependencies);
+    log.info("checking for updates...");
+    await (0, utils_1.runCommand)("npx npm-check-updates -u").promise;
+    log.info("updating...");
+    await (0, utils_1.runCommand)("npx npm run do-install").promise;
+}
+async function installIfNotAvailable(deps, dependencies) {
+    if (!dependencies) {
+        const d = await getDependencies();
+        dependencies = {
+            prod: d.prod?.map((p) => p.name) || [],
+            dev: d.dev?.map((d) => d.name) || [],
+            peer: d.peer?.map((p) => p.name) || [],
+        };
+    }
+    const { prod, dev, peer } = dependencies;
+    const installed = Array.from(new Set([...(prod || []), ...(dev || []), ...(peer || [])]));
+    deps = typeof deps === "string" ? [deps] : deps;
+    const toInstall = deps.filter((d) => !installed.includes(d));
+    if (toInstall.length)
+        await installDependencies({ dev: toInstall });
+    dependencies.dev = dependencies.dev || [];
+    dependencies.dev.push(...toInstall);
+    return dependencies;
+}
+async function pushToGit() {
+    const log = logger.for(pushToGit);
+    const gitUser = await (0, utils_1.runCommand)("git config user.name").promise;
+    const gitEmail = await (0, utils_1.runCommand)("git config user.email").promise;
+    log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);
+    await (0, utils_1.runCommand)('git config user.email "automation@decaf.ts"').promise;
+    await (0, utils_1.runCommand)('git config user.name "decaf"').promise;
+    log.info("Pushing changes to git...");
+    await (0, utils_1.runCommand)("git add .").promise;
+    await (0, utils_1.runCommand)(`git commit -m "refs #1 - after repo setup"`).promise;
+    await (0, utils_1.runCommand)("git push").promise;
+    await (0, utils_1.runCommand)(`git config user.email "${gitEmail}"`).promise;
+    await (0, utils_1.runCommand)(`git config user.name "${gitUser}"`).promise;
+    log.verbose(`reverted to git id: ${gitUser}/${gitEmail}`);
+}
+async function installDependencies(dependencies) {
+    const log = logger.for(installDependencies);
+    const prod = dependencies.prod || [];
+    const dev = dependencies.dev || [];
+    const peer = dependencies.peer || [];
+    if (prod.length) {
+        log.info(`Installing dependencies ${prod.join(", ")}...`);
+        await (0, utils_1.runCommand)(`npm install ${prod.join(" ")}`, { cwd: process.cwd() })
+            .promise;
+    }
+    if (dev.length) {
+        log.info(`Installing devDependencies ${dev.join(", ")}...`);
+        await (0, utils_1.runCommand)(`npm install --save-dev ${dev.join(" ")}`, {
+            cwd: process.cwd(),
+        }).promise;
+    }
+    if (peer.length) {
+        log.info(`Installing peerDependencies ${peer.join(", ")}...`);
+        await (0, utils_1.runCommand)(`npm install --save-peer ${peer.join(" ")}`, {
+            cwd: process.cwd(),
+        }).promise;
+    }
+}
+async function normalizeImport(importPromise) {
+    // CommonJS's `module.exports` is wrapped as `default` in ESModule.
+    return importPromise.then((m) => (m.default || m));
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/fs.ts"],"names":[],"mappings":"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","file":"utils/fs.js","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { Logging } from \"../output/logging\";\nimport { patchString } from \"./text\";\nimport { runCommand } from \"./utils\";\nimport { DependencyMap, SimpleDependencyMap } from \"./types\";\n\nconst logger = Logging.for(\"fs\");\n\n/**\n * @description Patches a file with given values.\n * @summary Reads a file, applies patches using TextUtils, and writes the result back to the file.\n *\n * @param {string} path - The path to the file to be patched.\n * @param {Record<string, number | string>} values - The values to patch into the file.\n * @return {void}\n *\n * @function patchFile\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant patchFile\n *   participant fs\n *   participant readFile\n *   participant TextUtils\n *   participant writeFile\n *   Caller->>patchFile: Call with path and values\n *   patchFile->>fs: Check if file exists\n *   patchFile->>readFile: Read file content\n *   readFile->>fs: Read file\n *   fs-->>readFile: Return file content\n *   readFile-->>patchFile: Return file content\n *   patchFile->>TextUtils: Patch string\n *   TextUtils-->>patchFile: Return patched content\n *   patchFile->>writeFile: Write patched content\n *   writeFile->>fs: Write to file\n *   fs-->>writeFile: File written\n *   writeFile-->>patchFile: File written\n *   patchFile-->>Caller: Patching complete\n *\n * @memberOf module:fs-utils\n */\nexport function patchFile(\n  path: string,\n  values: Record<string, number | string>\n) {\n  const log = logger.for(patchFile);\n  if (!fs.existsSync(path))\n    throw new Error(`File not found at path \"${path}\".`);\n  let content = readFile(path);\n\n  try {\n    log.verbose(`Patching file \"${path}\"...`);\n    log.debug(`with value: ${JSON.stringify(values)}`);\n    content = patchString(content, values);\n  } catch (error: unknown) {\n    throw new Error(`Error patching file: ${error}`);\n  }\n  writeFile(path, content);\n}\n\n/**\n * @description Reads a file and returns its content.\n * @summary Reads the content of a file at the specified path and returns it as a string.\n *\n * @param {string} path - The path to the file to be read.\n * @return {string} The content of the file.\n *\n * @function readFile\n *\n * @memberOf module:utils\n */\nexport function readFile(path: string): string {\n  const log = logger.for(readFile);\n  try {\n    log.verbose(`Reading file \"${path}\"...`);\n    return fs.readFileSync(path, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error reading file \"${path}\": ${error}`);\n    throw new Error(`Error reading file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Writes data to a file.\n * @summary Writes the provided data to a file at the specified path.\n *\n * @param {string} path - The path to the file to be written.\n * @param {string | Buffer} data - The data to be written to the file.\n * @return {void}\n *\n * @function writeFile\n *\n * @memberOf module:utils\n */\nexport function writeFile(path: string, data: string | Buffer): void {\n  const log = logger.for(writeFile);\n  try {\n    log.verbose(`Writing file \"${path} with ${data.length} bytes...`);\n    fs.writeFileSync(path, data, \"utf8\");\n  } catch (error: unknown) {\n    log.verbose(`Error writing file \"${path}\": ${error}`);\n    throw new Error(`Error writing file \"${path}\": ${error}`);\n  }\n}\n\n/**\n * @description Retrieves package information from package.json.\n * @summary Loads and parses the package.json file from a specified directory or the current working directory. Can return the entire package object or a specific property.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @param {string} [property] - Optional. The specific property to retrieve from package.json.\n * @return {object | string} The parsed contents of package.json or the value of the specified property.\n * @function getPackage\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getPackage\n *   participant readFile\n *   participant JSON\n *   Caller->>getPackage: Call with path and optional property\n *   getPackage->>readFile: Read package.json\n *   readFile-->>getPackage: Return file content\n *   getPackage->>JSON: Parse file content\n *   JSON-->>getPackage: Return parsed object\n *   alt property specified\n *     getPackage->>getPackage: Check if property exists\n *     alt property exists\n *       getPackage-->>Caller: Return property value\n *     else property doesn't exist\n *       getPackage-->>Caller: Throw Error\n *     end\n *   else no property specified\n *     getPackage-->>Caller: Return entire package object\n *   end\n * @memberOf module:utils\n */\nexport function getPackage(\n  p: string = process.cwd(),\n  property?: string\n): object | string {\n  let pkg: any;\n  try {\n    pkg = JSON.parse(readFile(path.join(p, `package.json`)));\n  } catch (error: unknown) {\n    throw new Error(`Failed to retrieve package information\" ${error}`);\n  }\n\n  if (property) {\n    if (!(property in pkg))\n      throw new Error(`Property \"${property}\" not found in package.json`);\n    return pkg[property] as string;\n  }\n  return pkg;\n}\n\nexport function setPackageAttribute(\n  attr: string,\n  value: string,\n  p: string = process.cwd()\n): void {\n  const pkg = getPackage(p) as Record<string, any>;\n  pkg[attr] = value;\n  writeFile(path.join(p, `package.json`), JSON.stringify(pkg, null, 2));\n}\n\n/**\n * @description Retrieves the version from package.json.\n * @summary A convenience function that calls getPackage to retrieve the \"version\" property from package.json.\n * @param {string} [p=process.cwd()] - The directory path where the package.json file is located.\n * @return {string} The version string from package.json.\n * @function getPackageVersion\n * @memberOf module:fs-utils\n */\nexport function getPackageVersion(p = process.cwd()): string {\n  return getPackage(p, \"version\") as string;\n}\n\n/**\n * @description Retrieves all dependencies from the project.\n * @summary Executes 'npm ls --json' command to get a detailed list of all dependencies (production, development, and peer) and their versions.\n * @param {string} [path=process.cwd()] - The directory path of the project.\n * @return {Promise<{prod: Array<{name: string, version: string}>, dev: Array<{name: string, version: string}>, peer: Array<{name: string, version: string}>}>} An object containing arrays of production, development, and peer dependencies.\n * @function getDependencies\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant getDependencies\n *   participant runCommand\n *   participant JSON\n *   Caller->>getDependencies: Call with optional path\n *   getDependencies->>runCommand: Execute 'npm ls --json'\n *   runCommand-->>getDependencies: Return command output\n *   getDependencies->>JSON: Parse command output\n *   JSON-->>getDependencies: Return parsed object\n *   getDependencies->>getDependencies: Process dependencies\n *   getDependencies-->>Caller: Return processed dependencies\n * @memberOf module:fs-utils\n */\nexport async function getDependencies(\n  path: string = process.cwd()\n): Promise<DependencyMap> {\n  let pkg: any;\n\n  try {\n    pkg = JSON.parse(await runCommand(`npm ls --json`, { cwd: path }).promise);\n  } catch (e: unknown) {\n    throw new Error(`Failed to retrieve dependencies: ${e}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  const mapper = (entry: [string, unknown], index: number) => ({\n    name: entry[0],\n    version: (entry[1] as any).version,\n  });\n\n  return {\n    prod: Object.entries(pkg.dependencies || {}).map(mapper),\n    dev: Object.entries(pkg.devDependencies || {}).map(mapper),\n    peer: Object.entries(pkg.peerDependencies || {}).map(mapper),\n  };\n}\n\nexport async function updateDependencies() {\n  const log = logger.for(updateDependencies);\n  log.info(\"checking for updates...\");\n  await runCommand(\"npx npm-check-updates -u\").promise;\n  log.info(\"updating...\");\n  await runCommand(\"npx npm run do-install\").promise;\n}\n\nexport async function installIfNotAvailable(\n  deps: string[] | string,\n  dependencies?: SimpleDependencyMap\n) {\n  if (!dependencies) {\n    const d: DependencyMap = await getDependencies();\n    dependencies = {\n      prod: d.prod?.map((p) => p.name) || [],\n      dev: d.dev?.map((d) => d.name) || [],\n      peer: d.peer?.map((p) => p.name) || [],\n    };\n  }\n  const { prod, dev, peer } = dependencies;\n  const installed = Array.from(\n    new Set([...(prod || []), ...(dev || []), ...(peer || [])])\n  );\n  deps = typeof deps === \"string\" ? [deps] : deps;\n  const toInstall = deps.filter((d) => !installed.includes(d));\n\n  if (toInstall.length) await installDependencies({ dev: toInstall });\n  dependencies.dev = dependencies.dev || [];\n  dependencies.dev.push(...toInstall);\n  return dependencies;\n}\n\nexport async function pushToGit() {\n  const log = logger.for(pushToGit);\n  const gitUser = await runCommand(\"git config user.name\").promise;\n  const gitEmail = await runCommand(\"git config user.email\").promise;\n  log.verbose(`cached git id: ${gitUser}/${gitEmail}. changing to automation`);\n  await runCommand('git config user.email \"automation@decaf.ts\"').promise;\n  await runCommand('git config user.name \"decaf\"').promise;\n  log.info(\"Pushing changes to git...\");\n  await runCommand(\"git add .\").promise;\n  await runCommand(`git commit -m \"refs #1 - after repo setup\"`).promise;\n  await runCommand(\"git push\").promise;\n  await runCommand(`git config user.email \"${gitEmail}\"`).promise;\n  await runCommand(`git config user.name \"${gitUser}\"`).promise;\n  log.verbose(`reverted to git id: ${gitUser}/${gitEmail}`);\n}\n\nexport async function installDependencies(dependencies: {\n  prod?: string[];\n  dev?: string[];\n  peer?: string[];\n}) {\n  const log = logger.for(installDependencies);\n  const prod = dependencies.prod || [];\n  const dev = dependencies.dev || [];\n  const peer = dependencies.peer || [];\n  if (prod.length) {\n    log.info(`Installing dependencies ${prod.join(\", \")}...`);\n    await runCommand(`npm install ${prod.join(\" \")}`, { cwd: process.cwd() })\n      .promise;\n  }\n  if (dev.length) {\n    log.info(`Installing devDependencies ${dev.join(\", \")}...`);\n    await runCommand(`npm install --save-dev ${dev.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n  if (peer.length) {\n    log.info(`Installing peerDependencies ${peer.join(\", \")}...`);\n    await runCommand(`npm install --save-peer ${peer.join(\" \")}`, {\n      cwd: process.cwd(),\n    }).promise;\n  }\n}\n\nexport async function normalizeImport<T>(\n  importPromise: Promise<T>\n): Promise<T> {\n  // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n  return importPromise.then((m: any) => (m.default || m) as T);\n}\n"]}

package/lib/utils/http.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const https_1 = __importDefault(require("https"));
+const logging_1 = require("../output/logging.cjs");
+/**
+ * @description A simple HTTP client for downloading files.
+ * @summary This class provides functionality to download files from HTTPS URLs.
+ * It uses Node.js built-in https module to make requests.
+ *
+ * @class
+ */
+class HttpClient {
+    static { this.log = logging_1.Logging.for(HttpClient); }
+    /**
+     * @description Downloads a file from a given URL.
+     * @summary This method sends a GET request to the specified URL and returns the response body as a string.
+     * It handles different scenarios such as non-200 status codes and network errors.
+     *
+     * @param url - The URL of the file to download.
+     * @return A promise that resolves with the file content as a string.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant HttpClient
+     *   participant HTTPS
+     *   participant Server
+     *   Client->>HttpClient: downloadFile(url)
+     *   HttpClient->>HTTPS: get(url)
+     *   HTTPS->>Server: GET request
+     *   Server-->>HTTPS: Response
+     *   HTTPS-->>HttpClient: Response object
+     *   alt Status code is 200
+     *     loop For each data chunk
+     *       HTTPS->>HttpClient: 'data' event
+     *       HttpClient->>HttpClient: Accumulate data
+     *     end
+     *     HTTPS->>HttpClient: 'end' event
+     *     HttpClient-->>Client: Resolve with data
+     *   else Status code is not 200
+     *     HttpClient-->>Client: Reject with error
+     *   end
+     */
+    static async downloadFile(url) {
+        return new Promise((resolve, reject) => {
+            function request(url) {
+                url = encodeURI(url);
+                https_1.default.get(url, (res) => {
+                    if (res.statusCode === 301 || res.statusCode === 307)
+                        return request(res.headers.location);
+                    if (res.statusCode !== 200) {
+                        HttpClient.log.error(`Failed to fetch ${url} (status: ${res.statusCode})`);
+                        return reject(new Error(`Failed to fetch ${url}`));
+                    }
+                    let data = "";
+                    res.on("data", (chunk) => {
+                        data += chunk;
+                    });
+                    res.on("error", (error) => {
+                        reject(error);
+                    });
+                    res.on("end", () => {
+                        resolve(data);
+                    });
+                });
+            }
+            request(url);
+        });
+    }
+}
+exports.HttpClient = HttpClient;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/utils/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./environment.cjs"), exports);
+__exportStar(require("./fs.cjs"), exports);
+__exportStar(require("./http.cjs"), exports);
+__exportStar(require("./text.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./utils.cjs"), exports);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLGdEQUE4QjtBQUM5Qix1Q0FBcUI7QUFDckIseUNBQXVCO0FBQ3ZCLHlDQUF1QjtBQUN2QiwwQ0FBd0I7QUFDeEIsMENBQXdCIiwiZmlsZSI6InV0aWxzL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnZpcm9ubWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2h0dHBcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuIl19

package/lib/utils/md.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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