jitsu-cli 1.10.4 → 2.14.0-beta.101

package/compiled/src/commands/login.js

@@ -1,24 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logout = logout;
-exports.login = login;
-const tslib_1 = require("tslib");
-const juava_1 = require("juava");
-const fs = tslib_1.__importStar(require("fs"));
-const fs_1 = require("fs");
-const os_1 = require("os");
-const readline_1 = tslib_1.__importDefault(require("readline"));
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+import { decrypt, randomId } from "juava";
+import * as fs from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import readline from "readline";
+import { b, red } from "../lib/chalk-code-highlight";
+import inquirer from "inquirer";
 const origin = "jitsu-cli";
-async function logout({ force }) {
-    const jitsuFile = `${(0, os_1.homedir)()}/.jitsu/jitsu-cli.json`;
+export async function logout({ force }) {
+    const jitsuFile = `${homedir()}/.jitsu/jitsu-cli.json`;
     if (fs.existsSync(jitsuFile)) {
         if (force) {
             fs.unlinkSync(jitsuFile);
         }
         else {
-            const { confirm } = await inquirer_1.default.prompt([
+            const { confirm } = await inquirer.prompt([
                 {
                     type: "confirm",
                     name: "confirm",
@@ -40,15 +35,17 @@ async function logout({ force }) {
         console.log("You are not logged in");
     }
 }
-async function login({ host, apikey, force }) {
-    const jitsuFile = `${(0, os_1.homedir)()}/.jitsu/jitsu-cli.json`;
+export async function login({ host, apikey, force }) {
+    const jitsuDir = `${homedir()}/.jitsu`;
+    fs.mkdirSync(jitsuDir, { recursive: true });
+    const jitsuFile = `${jitsuDir}/jitsu-cli.json`;
     if (fs.existsSync(jitsuFile) && !force) {
-        const loginInfo = JSON.parse((0, fs_1.readFileSync)(jitsuFile, { encoding: "utf-8" }));
-        console.error((0, chalk_code_highlight_1.red)(`Error: seems like you already logged into jitsu at ${loginInfo.host}. If you want to re-login again, use --force flag, or logout first with \`jitsu-cli logout\` command`));
+        const loginInfo = JSON.parse(readFileSync(jitsuFile, { encoding: "utf-8" }));
+        console.error(red(`Error: seems like you already logged into jitsu at ${loginInfo.host}. If you want to re-login again, use --force flag, or logout first with \`jitsu-cli logout\` command`));
         process.exit(1);
     }
     if (apikey) {
-        (0, fs_1.writeFileSync)(jitsuFile, JSON.stringify({ host, apikey }, null, 2));
+        writeFileSync(jitsuFile, JSON.stringify({ host, apikey }, null, 2));
         console.info(`\nSuccess!`);
         return;
     }
@@ -65,9 +62,9 @@ async function login({ host, apikey, force }) {
         url += "/";
     }
     try {
-        const c = (0, juava_1.randomId)(32);
-        console.log(`Please open this url in your browser and log in:\n\n${(0, chalk_code_highlight_1.b)(`${url}?origin=${origin}&c=${c}`)}`);
-        const rl = readline_1.default.createInterface({
+        const c = randomId(32);
+        console.log(`Please open this url in your browser and log in:\n\n${b(`${url}?origin=${origin}&c=${c}`)}`);
+        const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
         });
@@ -86,14 +83,14 @@ function processCode(code, key, host) {
     try {
         const iv = `${origin}${code.substring(0, 16 - origin.length)}`;
         const enc = code.substring(16 - origin.length);
-        const decoded = (0, juava_1.decrypt)(key, iv, enc);
+        const decoded = decrypt(key, iv, enc);
         const { plaintext, id } = JSON.parse(decoded);
-        (0, fs_1.mkdirSync)(`${(0, os_1.homedir)()}/.jitsu`, { recursive: true });
-        (0, fs_1.writeFileSync)(`${(0, os_1.homedir)()}/.jitsu/jitsu-cli.json`, JSON.stringify({ host, apikey: `${id}:${plaintext}` }, null, 2));
+        mkdirSync(`${homedir()}/.jitsu`, { recursive: true });
+        writeFileSync(`${homedir()}/.jitsu/jitsu-cli.json`, JSON.stringify({ host, apikey: `${id}:${plaintext}` }, null, 2));
         console.info(`\nSuccess!`);
     }
     catch (e) {
-        console.error(`\n${(0, chalk_code_highlight_1.red)("Incorrect code value")}`);
+        console.error(`\n${red("Incorrect code value")}`);
         process.exit(1);
     }
 }

package/compiled/src/commands/shared.js

@@ -1,16 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPackageJson = loadPackageJson;
-exports.loadPackageJson0 = loadPackageJson0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
-const fs_1 = require("fs");
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-async function loadPackageJson(projectDir) {
+import path from "path";
+import inquirer from "inquirer";
+import { existsSync, readFileSync } from "fs";
+import { b, red } from "../lib/chalk-code-highlight";
+export async function loadPackageJson(projectDir) {
     let packageJson = loadPackageJson0(projectDir);
     if (!packageJson) {
-        projectDir = (await inquirer_1.default.prompt([
+        projectDir = (await inquirer.prompt([
             {
                 type: "input",
                 name: "dir",
@@ -24,15 +19,15 @@ async function loadPackageJson(projectDir) {
     }
     return { projectDir, packageJson };
 }
-function loadPackageJson0(projectDir) {
-    const packageJsonPath = path_1.default.resolve(projectDir, "package.json");
-    if (!(0, fs_1.existsSync)(packageJsonPath)) {
-        console.error((0, chalk_code_highlight_1.red)(`Can't find node.js project in: ${(0, chalk_code_highlight_1.b)(projectDir)}`));
+export function loadPackageJson0(projectDir) {
+    const packageJsonPath = path.resolve(projectDir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        console.error(red(`Can't find node.js project in: ${b(projectDir)}`));
         return undefined;
     }
-    const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson.devDependencies?.["jitsu-cli"]) {
-        console.error((0, chalk_code_highlight_1.red)(`directory ${(0, chalk_code_highlight_1.b)(projectDir)} doesn't contain jitsu-cli managed project`));
+        console.error(red(`directory ${b(projectDir)} doesn't contain jitsu-cli managed project`));
         return undefined;
     }
     return packageJson;

package/compiled/src/commands/spec.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { red } from "../lib/chalk-code-highlight";
+import { normalizeHost, readAuthFile, resolveAuth } from "../lib/auth-file";
+import { fetchSpec } from "../lib/spec";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS, print } from "../lib/renderer";
+export function buildSpecCommand() {
+    return new Command("spec")
+        .description("Print the live OpenAPI spec served at /api/spec")
+        .option("-o, --output <format>", `Output format: ${SUPPORTED_OUTPUTS.join(", ")}`, DEFAULT_OUTPUT)
+        .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+        .option("-k, --apikey <api-key>", "API key (overrides ~/.jitsu/jitsu-cli.json)")
+        .action(async (opts) => {
+        try {
+            const auth = (() => {
+                try {
+                    return resolveAuth(opts);
+                }
+                catch {
+                    const host = opts.host ?? readAuthFile()?.host ?? "https://use.jitsu.com";
+                    return { host: normalizeHost(host), apikey: "anonymous" };
+                }
+            })();
+            const spec = await fetchSpec(auth);
+            print(spec, opts.output);
+        }
+        catch (e) {
+            console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+            process.exit(1);
+        }
+    });
+}

package/compiled/src/commands/test.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = test;
-const jest_cli_1 = require("jest-cli");
-const shared_1 = require("./shared");
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-async function test({ dir }) {
-    const { packageJson, projectDir } = await (0, shared_1.loadPackageJson)(dir || process.cwd());
-    console.log(`Running tests for ${(0, chalk_code_highlight_1.b)(packageJson.name)}`);
+import { run as jest } from "jest-cli";
+import { loadPackageJson } from "./shared";
+import { b } from "../lib/chalk-code-highlight";
+export async function test({ dir }) {
+    const { packageJson, projectDir } = await loadPackageJson(dir || process.cwd());
+    console.log(`Running tests for ${b(packageJson.name)}`);
     const jestArgs = ["--passWithNoTests", "--projects", projectDir, "--preset", "ts-jest"];
-    await (0, jest_cli_1.run)(jestArgs);
+    await jest(jestArgs);
 }

package/compiled/src/commands/whoami.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.whoami = whoami;
-const tslib_1 = require("tslib");
-const os_1 = require("os");
-const fs = tslib_1.__importStar(require("fs"));
-const fs_1 = require("fs");
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-async function whoami({ host, apikey, force }) {
+import { homedir } from "os";
+import * as fs from "fs";
+import { readFileSync } from "fs";
+import { b } from "../lib/chalk-code-highlight";
+export async function whoami({ host, apikey, force }) {
     if (!apikey) {
-        const jitsuFile = `${(0, os_1.homedir)()}/.jitsu/jitsu-cli.json`;
+        const jitsuFile = `${homedir()}/.jitsu/jitsu-cli.json`;
         if (!fs.existsSync(jitsuFile)) {
             console.log("You are not logged in. Log in with `jitsu-cli login` or provide --apikey option");
             return;
         }
-        const loginInfo = JSON.parse((0, fs_1.readFileSync)(jitsuFile, { encoding: "utf-8" }));
+        const loginInfo = JSON.parse(readFileSync(jitsuFile, { encoding: "utf-8" }));
         if (loginInfo.host) {
             host = loginInfo.host;
         }
@@ -40,5 +36,5 @@ async function whoami({ host, apikey, force }) {
     if (!me.auth) {
         console.error(`Login is invalid. Please login once again with \`jitsu-cli login -f\`, or provide a valid --apikey option`);
     }
-    console.log(`You are logged in as ${(0, chalk_code_highlight_1.b)(me.user.email)} at ${host}. Internal userId: ${(0, chalk_code_highlight_1.b)(me.user.internalId)}`);
+    console.log(`You are logged in as ${b(me.user.email)} at ${host}. Internal userId: ${b(me.user.internalId)}`);
 }

package/compiled/src/index.js

@@ -1,44 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const figlet_1 = tslib_1.__importDefault(require("figlet"));
-const commander_1 = require("commander");
-const login_1 = require("./commands/login");
-const deploy_1 = require("./commands/deploy");
-const init_1 = require("./commands/init");
-const build_1 = require("./commands/build");
-const test_1 = require("./commands/test");
-const version_1 = require("./lib/version");
-const whoami_1 = require("./commands/whoami");
-console.log(figlet_1.default.textSync("Jitsu CLI", { horizontalLayout: "full" }));
-const p = new commander_1.Command();
-p.name(version_1.jitsuCliPackageName).description("CLI command to create, test and deploy extensions for Jitsu Next");
+import figlet from "figlet";
+import { Command } from "commander";
+import { login, logout } from "./commands/login";
+import { deploy } from "./commands/deploy";
+import { init } from "./commands/init";
+import { build } from "./commands/build";
+import { test } from "./commands/test";
+import { jitsuCliVersion, jitsuCliPackageName } from "./lib/version";
+import { whoami } from "./commands/whoami";
+import { buildConfigCommand } from "./commands/config";
+import { buildSpecCommand } from "./commands/spec";
+import { setDefaultWorkspace, unsetDefaultWorkspace } from "./commands/default-workspace";
+import { preprocessArgv } from "./lib/body-fields";
+process.argv = preprocessArgv(process.argv);
+const isPipedStdout = !process.stdout.isTTY;
+if (!isPipedStdout) {
+    process.stderr.write(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }) + "\n");
+}
+const p = new Command();
+p.name(jitsuCliPackageName).description("Jitsu CLI — manage workspaces, configuration objects, and extensions");
 p.command("init")
     .description("Initialize a new Jitsu extension project")
     .arguments("[dir]")
     .option("-j, --jitsu-version <version>", "Jitsu version to use in package.json. (Optional)")
     .option("--allow-non-empty-dir", "Allow to create project in non-empty directory. (Optional)")
-    .action(init_1.init);
+    .action(init);
 p.command("build")
     .description("Build the extension")
     .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
-    .action(build_1.build);
+    .action(build);
 p.command("test")
     .description("Run test provided with the extension")
     .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
-    .action(test_1.test);
+    .action(test);
 p.command("whoami")
     .description("Check if current user is logged in. Shows user's info if logged in")
     .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
     .option("-k, --apikey <api-key>", "Jitsu user's Api Key. (Optional). Disables interactive login.")
-    .action(whoami_1.whoami);
+    .action(whoami);
 p.command("login")
     .description("Login to Jitsu and remember credentials in `~/.jitsu/jitsu-cli.json` file")
     .option("-f, --force", "If user already logged in, replace existing session")
     .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
     .option("-k, --apikey <api-key>", "Jitsu user's Api Key. (Optional). Disables interactive login.")
-    .action(login_1.login);
-p.command("logout").description("Logout").option("-f, --force", "Do not ask for confirmation").action(login_1.logout);
+    .action(login);
+p.command("logout").description("Logout").option("-f, --force", "Do not ask for confirmation").action(logout);
 p.command("deploy")
     .description("Deploy functions to Jitsu project")
     .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
@@ -47,7 +52,18 @@ p.command("deploy")
     .option("-w, --workspace <workspace-id>", "Id of workspace where to deploy function (Optional). By default, interactive prompt is shown to select workspace")
     .option("-t, --type <type>", "entity type to deploy", "function")
     .option("-n, --name <name...>", "limit deploy to provided entities only. (Optional)")
-    .action(deploy_1.deploy);
-p.version(version_1.jitsuCliPackageName + " " + version_1.jitsuCliVersion, "-v, --version");
+    .action(deploy);
+p.command("set-default-workspace")
+    .description("Save a default workspace to ~/.jitsu/jitsu-cli.json. Subsequent `jitsu config` commands use it when -w is omitted.")
+    .argument("<id-or-slug>", "Workspace id or slug")
+    .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+    .option("-k, --apikey <api-key>", "API key in form keyId:secret (overrides ~/.jitsu/jitsu-cli.json)")
+    .action(setDefaultWorkspace);
+p.command("unset-default-workspace")
+    .description("Remove the saved default workspace from ~/.jitsu/jitsu-cli.json")
+    .action(unsetDefaultWorkspace);
+p.addCommand(buildConfigCommand());
+p.addCommand(buildSpecCommand());
+p.version(jitsuCliPackageName + " " + jitsuCliVersion, "-v, --version");
 p.helpOption("--help", "display help for command");
 p.parse();

package/compiled/src/lib/api-client.js

@@ -0,0 +1,52 @@
+export class ApiError extends Error {
+    constructor(status, message, payload) {
+        super(message);
+        this.status = status;
+        this.payload = payload;
+    }
+}
+export class ApiClient {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    url(path, query) {
+        const base = this.auth.host;
+        const p = path.startsWith("/") ? path : `/${path}`;
+        if (!query)
+            return `${base}${p}`;
+        const qs = Object.entries(query)
+            .filter(([, v]) => v !== undefined && v !== null && v !== "")
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join("&");
+        return qs ? `${base}${p}?${qs}` : `${base}${p}`;
+    }
+    async request(req) {
+        const method = req.method ?? "GET";
+        const headers = {
+            Accept: "application/json",
+            Authorization: `Bearer ${this.auth.apikey}`,
+        };
+        let body;
+        if (req.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(req.body);
+        }
+        const res = await fetch(this.url(req.path, req.query), { method, headers, body });
+        const text = await res.text();
+        let parsed = text;
+        if (text && res.headers.get("content-type")?.includes("application/json")) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+            }
+        }
+        if (!res.ok) {
+            const msg = (parsed && typeof parsed === "object" && "message" in parsed
+                ? String(parsed.message)
+                : undefined) ?? `HTTP ${res.status} ${method} ${req.path}`;
+            throw new ApiError(res.status, msg, parsed);
+        }
+        return parsed;
+    }
+}

package/compiled/src/lib/auth-file.js

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+const DEFAULT_HOST = "https://use.jitsu.com";
+export function authFilePath() {
+    return `${homedir()}/.jitsu/jitsu-cli.json`;
+}
+export function readAuthFile() {
+    const path = authFilePath();
+    if (!fs.existsSync(path))
+        return undefined;
+    return JSON.parse(readFileSync(path, { encoding: "utf-8" }));
+}
+export function updateAuthFile(patch) {
+    const path = authFilePath();
+    const existing = readAuthFile() ?? {};
+    const next = { ...existing };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined)
+            delete next[k];
+        else
+            next[k] = v;
+    }
+    mkdirSync(`${homedir()}/.jitsu`, { recursive: true });
+    writeFileSync(path, JSON.stringify(next, null, 2));
+    return next;
+}
+export function readDefaultWorkspace() {
+    return readAuthFile()?.defaultWorkspace;
+}
+export function resolveAuth(opts) {
+    let host = opts.host;
+    let apikey = opts.apikey;
+    if (!host || !apikey) {
+        const file = readAuthFile();
+        if (file) {
+            if (!host)
+                host = file.host;
+            if (!apikey)
+                apikey = file.apikey;
+        }
+    }
+    if (!host)
+        host = process.env.JITSU_HOST;
+    if (!apikey)
+        apikey = process.env.JITSU_APIKEY;
+    if (!host)
+        host = DEFAULT_HOST;
+    if (!apikey) {
+        throw new Error("Not authenticated. Run `jitsu login`, set JITSU_APIKEY, or pass --apikey <key>.");
+    }
+    return { host: normalizeHost(host), apikey };
+}
+export function normalizeHost(host) {
+    let url = host;
+    if (!url.startsWith("http")) {
+        if (url.startsWith("localhost") || /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/.test(url)) {
+            url = "http://" + url;
+        }
+        else {
+            url = "https://" + url;
+        }
+    }
+    if (url.endsWith("/"))
+        url = url.slice(0, -1);
+    return url;
+}

package/compiled/src/lib/body-builder.js

@@ -0,0 +1,53 @@
+import * as fs from "fs";
+import yaml from "js-yaml";
+import { parseScalar, setDottedPath } from "./dotted";
+export function buildBody(sources) {
+    const layers = [];
+    if (sources.file)
+        layers.push(loadFile(sources.file));
+    if (sources.json)
+        layers.push(parseInlineJson(sources.json));
+    if (sources.fields && Object.keys(sources.fields).length > 0) {
+        const obj = {};
+        for (const [path, raw] of Object.entries(sources.fields)) {
+            setDottedPath(obj, path, parseScalar(raw));
+        }
+        layers.push(obj);
+    }
+    if (layers.length === 0)
+        return undefined;
+    return layers.reduce((acc, layer) => deepMerge(acc, layer), {});
+}
+function loadFile(path) {
+    const text = path === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(path, "utf-8");
+    const parsed = yaml.load(text);
+    if (parsed === null || parsed === undefined) {
+        throw new Error(`File ${path} parsed as empty`);
+    }
+    return parsed;
+}
+function parseInlineJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch (e) {
+        throw new Error(`--json value is not valid JSON: ${e.message}`);
+    }
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(target, source) {
+    if (!isPlainObject(target) || !isPlainObject(source))
+        return source;
+    const out = { ...target };
+    for (const [k, v] of Object.entries(source)) {
+        if (isPlainObject(v) && isPlainObject(out[k])) {
+            out[k] = deepMerge(out[k], v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}

package/compiled/src/lib/body-fields.js

@@ -0,0 +1,47 @@
+const RESERVED = new Set([
+    "workspace",
+    "output",
+    "host",
+    "apikey",
+    "file",
+    "json",
+    "cascade",
+    "strict",
+    "from",
+    "to",
+    "help",
+    "version",
+]);
+const fields = {};
+function shouldExtract(argv) {
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith("-"))
+            continue;
+        return a === "config";
+    }
+    return false;
+}
+export function preprocessArgv(argv) {
+    if (!shouldExtract(argv))
+        return argv;
+    const out = [];
+    for (const arg of argv) {
+        const m = /^--([a-zA-Z][\w.-]*)=([\s\S]*)$/.exec(arg);
+        if (m) {
+            const head = m[1].split(".")[0];
+            if (!RESERVED.has(head)) {
+                fields[m[1]] = m[2];
+                continue;
+            }
+        }
+        out.push(arg);
+    }
+    return out;
+}
+export function consumeBodyFields() {
+    const copy = { ...fields };
+    for (const k of Object.keys(fields))
+        delete fields[k];
+    return copy;
+}

package/compiled/src/lib/chalk-code-highlight.js

@@ -1,31 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.yellow = exports.green = exports.red = exports.b = exports.defaultColorScheme = void 0;
-exports.chalkCode = chalkCode;
-const tslib_1 = require("tslib");
-const prismjs_1 = tslib_1.__importDefault(require("prismjs"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-exports.defaultColorScheme = {
+import Prism from "prismjs";
+import chalk from "chalk";
+export const defaultColorScheme = {
     punctuation: "#999",
     operator: "#9a6e3a",
     string: "#9a6e3a",
     keyword: "b#07a",
     "function-variable": null,
 };
-exports.b = chalk_1.default.bold;
-exports.red = chalk_1.default.red;
-exports.green = chalk_1.default.green;
-exports.yellow = chalk_1.default.yellow;
+export const b = chalk.bold;
+export const red = chalk.red;
+export const green = chalk.green;
+export const yellow = chalk.yellow;
 function chalkString(expr, str) {
     if (expr.startsWith("b")) {
-        return (0, exports.b)(chalkString(expr.substring(1), str));
+        return b(chalkString(expr.substring(1), str));
     }
     else {
-        return chalk_1.default.hex(expr)(str);
+        return chalk.hex(expr)(str);
     }
 }
-function chalkCode(code, lang, colorScheme = exports.defaultColorScheme) {
-    return prismjs_1.default.tokenize(code, prismjs_1.default.languages.javascript)
+export function chalkCode(code, lang, colorScheme = defaultColorScheme) {
+    return Prism.tokenize(code, Prism.languages.javascript)
         .map(element => {
         if (typeof element === "string") {
             return element;
@@ -37,9 +32,9 @@ function chalkCode(code, lang, colorScheme = exports.defaultColorScheme) {
     })
         .join("");
 }
-chalkCode.typescript = (code, colorScheme = exports.defaultColorScheme) => {
-    return chalkCode(typeof code === "string" ? code : code.join("\n"), prismjs_1.default.languages.typescript, colorScheme);
+chalkCode.typescript = (code, colorScheme = defaultColorScheme) => {
+    return chalkCode(typeof code === "string" ? code : code.join("\n"), Prism.languages.typescript, colorScheme);
 };
-chalkCode.json = (code, colorScheme = exports.defaultColorScheme) => {
-    return chalkCode(typeof code === "string" ? code : code.join("\n"), prismjs_1.default.languages.json, colorScheme);
+chalkCode.json = (code, colorScheme = defaultColorScheme) => {
+    return chalkCode(typeof code === "string" ? code : code.join("\n"), Prism.languages.json, colorScheme);
 };