@vistta/cli 1.0.1 → 1.1.0

package/README.md

@@ -45,6 +45,8 @@ npm install @vistta/cli
 - `vistta test [pattern]`  
   Run tests matching the specified pattern.
 
+For browser-based test harnesses, import `TestRunner` from `@vistta/cli/test-runner` to avoid bundling Node-only CLI modules.
+
 ## Extending the CLI
 
 You can create custom loaders and commands to fit your workflow.
@@ -108,7 +110,7 @@ vistta my-command [options]
 
 ## **License**
 
-Apache 2.0 with Commons Clause
+Licensed under the GNU General Public License version 3 only (`GPL-3.0-only`). See [LICENSE](LICENSE) for the full terms.
 
 ## **Contributing**
 

package/bin.js

@@ -9,7 +9,7 @@ const dirname = import.meta.dirname;
 const cwd = process.cwd();
 const rootPackage = await importJSON(fs.resolve(dirname, "package.json"));
 const projectPackage = await importJSON(fs.resolve(cwd, "package.json"));
-const env = await importEnv(fs.resolve(cwd, ".env"));
+const env = { ...process.env, ...(await importEnv(fs.resolve(cwd, ".env"))) };
 const projectEnvKeys = Object.keys(projectPackage?.env || {});
 for (let i = 0, len = projectEnvKeys.length; i < len; i++) env[projectEnvKeys[i]] = projectPackage.env[projectEnvKeys[i]];
 env.NODE_ENV = "production";
@@ -43,9 +43,15 @@ start(fs.resolve(dirname, "main.js"), argv, {
   stdio: env.NODE_SILENT ? "ignore" : "inherit",
 });
 
-function start(...args) {
-  fork(...args).on("exit", (code) => {
-    if (env.NODE_AUTO_RESTART && code != 0) start(...args);
+function start(modulePath, argv, options) {
+  const subprocess = fork(modulePath, argv, options);
+  let restart = false;
+  subprocess.on("message", (message) => {
+    if (typeof message === "object" && message && "restart" in message && message.restart)
+      ((restart = true), subprocess.kill());
+  });
+  subprocess.on("exit", (code) => {
+    if ((env.NODE_AUTO_RESTART && code != 0) || restart) start(modulePath, argv, options);
     else process.exit(code);
   });
 }

package/classes/bundler.js

@@ -1,56 +1,124 @@
 import fs from "@vistta/fs";
 import { build } from "esbuild";
-import { pathToFileURL } from "node:url";
-import { assign, extract } from "../utils.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { assign, extract, stripBundler } from "../utils.js";
 import { Command } from "./command.js";
 import { Runtime } from "./runtime.js";
 
+/**
+ * @typedef {{
+ *  paths?: Record<string, any>;
+ *  exports?: string;
+ *  sideEffects?: "none" | string | boolean;
+ *  importAttributes?: Record<string, any>;
+ *  [key: string]: any;
+ * }} BundlerRunOptions
+ */
+
+/**
+ * @typedef {{
+ *  code: string;
+ *  files: string[];
+ *  resources: Record<string, any>;
+ *  errors: any[];
+ *  warnings: any[];
+ *  warning?: any;
+ * }} BundlerRunResult
+ */
+
+/**
+ * @typedef {{
+ *  entries: string[];
+ *  files: string[];
+ *  resources: Record<string, any>;
+ *  loader: Runtime;
+ *  paths?: Record<string, any>;
+ *  exports?: string;
+ *  sideEffects?: boolean;
+ *  platform?: string;
+ *  importAttributes?: Record<string, any>;
+ * }} SetupOptions
+ */
+
 export class Bundler {
+  /** @type {Runtime} */
   #loader;
+  /** @type {BundlerRunOptions} */
   #options;
 
+  /**
+   * @param {Runtime | Command | undefined} [arg1]
+   */
   constructor(arg1) {
     if (arg1 instanceof Runtime) this.#loader = arg1;
-    else if (arg1 instanceof Command) this.#loader = new Runtime(arg1);
+    else if (arg1 instanceof Command)
+      this.#loader = new Runtime({
+        loaders: arg1.loaders,
+        resolvers: arg1.resolvers,
+        options: process.vistta?.options || {},
+      });
     else if (!arg1) this.#loader = new Runtime(process.vistta);
     else throw new Error("Invalid first argument. Expected Loader or CLI instance.");
     this.#options = this.#loader?.options?.bundler ?? {};
   }
 
-  async run(filename, options = {}) {
+  /**
+   * @param {string | string[]} target
+   * @param {BundlerRunOptions} [options]
+   * @returns {Promise<BundlerRunResult>}
+   */
+  async run(target, options = {}) {
     const files = [];
     const resources = {};
-    assign(options, this.#options);
-    const [paths, exports] = extract(options, "paths", "exports");
-    options.entryPoints = [exports ? "@exports" : filename];
+    options = assign({ ...options }, this.#options);
+    const [paths, exports, sideEffects, importAttributes] = extract(
+      options,
+      "paths",
+      "exports",
+      "sideEffects",
+      "importAttributes",
+    );
+    const multiple = Array.isArray(target);
+    if (exports && multiple) throw new Error("Cannot use 'exports' option with multiple entry points");
+    const entries = multiple ? target : [target];
+    options.entryPoints = exports ? ["@exports"] : multiple ? ["@bundle"] : entries;
     options.bundle = true;
     options.outdir ??= "dist";
     options.legalComments ??= "none";
     options.keepNames ??= true;
     options.treeShaking ??= true;
-    options.define ??= {};
     options.plugins = [];
     options.minify ??= process.env.NODE_ENV === "production";
     options.format ??= options.globalName ? "iife" : "esm";
     options.target ??= "esnext";
-    options.define[`process`] = "undefined";
-    const keys = Object.keys(process.env);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      if (/[():;,.\s]/.test(keys[i])) continue;
-      options.define[`process.env.${keys[i]}`] = JSON.stringify(process.env[keys[i]]);
+    options.logLevel ??= "error";
+    options.define ??= {};
+    if (options.platform !== "node") {
+      options.define[`process`] = "undefined";
+      const keys = Object.keys(process.env);
+      for (let i = 0, len = keys.length; i < len; i++) {
+        if (/[():;,.\s]/.test(keys[i])) continue;
+        options.define[`process.env.${keys[i]}`] = JSON.stringify(process.env[keys[i]]);
+      }
     }
     options.plugins.unshift(
       setup({
+        entries,
         loader: this.#loader,
         paths,
-        filename,
         files,
         resources,
         exports,
+        sideEffects: sideEffects !== "none",
         platform: options.platform,
+        importAttributes,
       }),
     );
     const { outputFiles, errors, warnings } = await build(options);
+    if ((outputFiles?.length ?? 0) > 1)
+      throw new Error(
+        `Unexpected Bundler Error: Expected 1 output file, but got ${outputFiles.length}. Please report this issue.`,
+      );
     return {
       code: outputFiles?.[0]?.text ?? "",
       files: Array.from(new Set(files)),
@@ -60,49 +128,92 @@ export class Bundler {
     };
   }
 
-  async import(filename, options = {}) {
+  /**
+   * @param {string} target
+   * @param {BundlerRunOptions} [options]
+   * @returns {Promise<any>}
+   */
+  async import(target, options = {}) {
     options.write = false;
-    const { code, errors, warning } = await this.run(filename, options);
+    const { code, errors, warning } = await this.run(target, options);
     if (code === "") return { errors, warning };
     return await import(`data:text/javascript;base64,${Buffer.from(code).toString(`base64`)}`);
   }
 }
 
-function setup({ files: bundlerFiles, resources: bundlerResources, filename, loader, paths = {}, exports, platform }) {
+/**
+ * @param {SetupOptions} options
+ */
+function setup({
+  entries,
+  files: bundlerFiles,
+  resources: bundlerResources,
+  loader,
+  paths = {},
+  exports,
+  sideEffects,
+  platform,
+  importAttributes: bundlerImportAttributes = {},
+}) {
   const filter = /.*/;
-  const basename = fs.basename(filename);
-  const dirname = fs.dirname(filename);
   return {
     name: "vistta",
     setup: (build) => (
       build.onResolve({ filter }, async ({ path, importer, resolveDir }) => {
-        if (path === "@exports") return { path: basename, namespace: "exports" };
-        if (paths[path]) return paths[path];
-        if (!fs.isAbsolute(importer)) importer = fs.resolve(resolveDir, importer);
+        const cleanPath = stripBundler(path);
+        if (cleanPath === "@exports") return { path: "@exports", namespace: "exports", sideEffects };
+        if (cleanPath === "@bundle") return { path: "@bundle", namespace: "bundle", sideEffects };
+        if (paths[cleanPath]) {
+          const mapping = paths[cleanPath];
+          if (mapping.namespace !== "window") return Object.assign({ sideEffects }, mapping);
+          const names = await getImportNames(importer, cleanPath);
+          return {
+            path: `${cleanPath}?window-import=${encodeURIComponent(importer)}`,
+            namespace: "window",
+            pluginData: { name: mapping.path, names },
+            sideEffects,
+          };
+        }
+        const isVirtualPath = importer === "@exports" || importer === "@bundle";
+        if (!isVirtualPath && !fs.isAbsolute(importer)) importer = fs.resolve(resolveDir, importer);
         const { final, builtin, file } = await loader.resolve(
-          path,
+          cleanPath,
           {
             conditions: ["bundler"],
-            parentURL: pathToFileURL(importer).href,
+            parentURL: !isVirtualPath ? pathToFileURL(importer).href : undefined,
           },
           (final, { builtin, file }) => ({ final, builtin, file }),
         );
-        if (!builtin && file) return { path: final };
+        const cleanFinal = stripBundler(final);
+        const finalPath = cleanFinal.startsWith("file://") ? fileURLToPath(cleanFinal) : cleanFinal;
+        if (!builtin && file) return { path: finalPath, sideEffects };
+        if (!builtin) return { sideEffects };
         if (platform === "node") return { external: true };
-        if (!builtin) return {};
-        return { path: final, namespace: "ignore" };
+        return { path: finalPath, namespace: "ignore" };
       }),
-      build.onLoad({ filter }, async ({ path, namespace, with: importAttributes = {} }) => {
+      build.onLoad({ filter }, async ({ path, namespace, pluginData, with: importAttributes }) => {
+        const cleanPath = stripBundler(path);
         if (namespace === "ignore") return { contents: "" };
-        if (namespace === "window") return { contents: `module.exports = window.${path};` };
-        if (namespace === "global") return { contents: `module.exports = global.${path};` };
-        if (namespace === "exports")
-          return {
-            contents: `export { ${exports} } from "./${basename}";`,
-            resolveDir: dirname,
-          };
+        if (namespace === "window") return { contents: createWindowModule(pluginData.name, pluginData.names) };
+        if (namespace === "global") return { contents: `module.exports = global.${cleanPath};` };
+        if (namespace === "exports") {
+          if (exports === "*") return { contents: `export * from ${JSON.stringify(entries[0])};` };
+          return { contents: `export { ${exports} } from ${JSON.stringify(entries[0])};` };
+        }
+        if (namespace === "bundle") {
+          let contents = "";
+          for (let i = 0, len = entries.length; i < len; i++) contents += `export * from ${JSON.stringify(entries[i])};\n`;
+          return { contents };
+        }
+        if (importAttributes.type === "bundler") delete importAttributes.type;
         importAttributes.bundler = true;
-        const { source, resources, files = [] } = await loader.load(path, { importAttributes }, () => ({}));
+        const mergedImportAttributes = { ...bundlerImportAttributes, ...importAttributes };
+        if (cleanPath.match(/\.(jsx|tsx)$/)) delete mergedImportAttributes.type;
+        const {
+          source,
+          resources,
+          files = [],
+        } = await loader.load(cleanPath, { importAttributes: mergedImportAttributes }, () => ({}));
         bundlerFiles.push(...files);
         if (!source) return { loader: "js" };
         for (let i = 0, len = resources?.length || 0; i < len; i++) {
@@ -114,3 +225,28 @@ function setup({ files: bundlerFiles, resources: bundlerResources, filename, loa
     ),
   };
 }
+
+async function getImportNames(importer, path) {
+  if (!importer || !fs.existsSync(importer)) return [];
+  const source = String(await fs.readFile(importer, "utf8"));
+  const escapedPath = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:import\\s+(?:[\\w$]+\\s*,\\s*)?|export\\s*){([^}]+)}\\s*from\\s*["']${escapedPath}["']`,
+    "g",
+  );
+  const names = new Set();
+  for (const match of source.matchAll(pattern)) {
+    for (const specifier of match[1].split(",")) names.add(specifier.trim().split(/\s+as\s+/i)[0]);
+  }
+  return [...names].filter(Boolean);
+}
+
+function createWindowModule(name, names) {
+  const getNamespace = `() => window[${JSON.stringify(name)}]`;
+  let contents = `const getNamespace = ${getNamespace};\nconst exports = {};\nObject.defineProperty(exports, "__esModule", { value: true });\n`;
+  contents += `Object.defineProperty(exports, "default", { enumerable: true, get: () => { const namespace = getNamespace(); return namespace?.default ?? namespace; } });\n`;
+  for (const exportName of names)
+    contents += `Object.defineProperty(exports, ${JSON.stringify(exportName)}, { enumerable: true, get: () => getNamespace()?.[${JSON.stringify(exportName)}] });\n`;
+  contents += `module.exports = new Proxy(exports, { get: (exports, name) => Reflect.has(exports, name) ? Reflect.get(exports, name) : (getNamespace()?.default ?? getNamespace())?.[name] });\n`;
+  return contents;
+}

package/classes/loader.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-unused-vars */
 export class Loader {
-  constructor() {}
+  constructor(options) {}
 
   /**
    * Main method to execute the loader.

package/classes/runtime.js

@@ -1,11 +1,9 @@
 import fs from "@vistta/fs";
 import { isBuiltin } from "node:module";
 import { fileURLToPath, pathToFileURL, URLSearchParams } from "node:url";
+import { CWD, FALLBACK, markAttributes, markBundler, stripBundler, WITH_TYPE_RE } from "../utils.js";
 import { Loader } from "./loader.js";
 
-const CWD = process.cwd();
-const FALLBACK = "*";
-
 export class Runtime {
   static Error = class extends Error {
     constructor(name, message) {
@@ -17,22 +15,27 @@ export class Runtime {
   #init;
   #loaders;
   #resolvers;
+  /** @type {Record<string, any>} */
   #options;
 
   get loaders() {
     return this.#loaders;
   }
 
+  /** @returns {Record<string, any>} */
   get options() {
     return this.#options;
   }
 
-  constructor({ loaders, resolvers, options }) {
+  /**
+   * @param {{ loaders?: any[]; resolvers?: string[]; options?: Record<string, any> }} [config]
+   */
+  constructor({ loaders = [], resolvers = [], options = {} } = {}) {
     this.#init = async () => {
       this.#loaders = {};
-      for (let i = 0, len = loaders?.length || 0; i < len; i++) {
+      for (let i = 0, len = loaders.length; i < len; i++) {
         let { main, type, filter } = loaders[i];
-        const { default: LoaderClass } = await import(main);
+        const { default: LoaderClass } = await import(pathToFileURL(main).href);
         if (!(LoaderClass?.prototype instanceof Loader)) throw new Runtime.Error(`Invalid loader "${loaders[i].main}"`);
         if (!type) type = FALLBACK;
         if (!this.#loaders[type]) this.#loaders[type] = {};
@@ -48,8 +51,11 @@ export class Runtime {
     [specifier, options] = specifier.split(/\?(.*)/);
     options = new URLSearchParams(options);
     const { parentURL = CWD, conditions: [type] = [] } = context;
+    const importType = context?.importAttributes?.type;
+    const isBundler = type === "bundler" || importType === "bundler";
+    const cleanParentURL = stripBundler(parentURL);
     if (isBuiltin(specifier)) {
-      if (type === "bundler") context.builtin = true;
+      if (isBundler) context.builtin = true;
       return nextResolve(specifier, context);
     }
 
@@ -74,7 +80,7 @@ export class Runtime {
     if (specifier?.startsWith("file://")) specifier = fileURLToPath(specifier);
 
     if (!fs.isAbsolute(specifier))
-      specifier = fs.resolve(parentURL?.startsWith("file://") ? fs.dirname(parentURL) : parentURL, specifier);
+      specifier = fs.resolve(cleanParentURL?.startsWith("file://") ? fs.dirname(cleanParentURL) : cleanParentURL, specifier);
     const len = this.#resolvers.length;
     if (fs.existsSync(specifier)) {
       if (fs.isDirectory(specifier)) {
@@ -95,22 +101,26 @@ export class Runtime {
         }
       }
 
-    if (type === "bundler") {
+    if (isBundler) {
       if (fs.isAbsolute(specifier)) context.file = true;
-      return nextResolve(specifier, context);
+      return nextResolve(markBundler(pathToFileURL(specifier).href), context);
     }
 
+    let query = "";
     const params = options.toString();
-    specifier = pathToFileURL(specifier).href;
-    if (params.length > 0) return nextResolve(`${specifier}?${params}`, context);
-    return nextResolve(specifier, context);
+    if (params) query = params;
+    const attrSuffix = markAttributes(context?.importAttributes);
+    if (attrSuffix) query += (query ? "&" : "") + attrSuffix;
+    let url = pathToFileURL(specifier).href;
+    if (query) url += (url.includes("?") ? "&" : "?") + query;
+    return nextResolve(url, context);
   }
 
   async load(url, context, nextLoad) {
     if (isBuiltin(url)) return nextLoad(url, context);
     const { ...options } = context?.importAttributes || {};
-    url = options.bundler ? pathToFileURL(url.split("?")[0]).href : url.split("?")[0];
-    const path = fileURLToPath(url);
+    const cleanUrl = url.replace(WITH_TYPE_RE, "").split("?")[0];
+    const path = cleanUrl.startsWith("file://") ? fileURLToPath(cleanUrl) : cleanUrl;
     const loader = match(this.#loaders, path, options.type);
     if (!loader) return nextLoad(url, context);
     options.path = path;

package/classes/test-runner.js

@@ -0,0 +1,210 @@
+/**
+ * @typedef {{ only?: boolean; filter?: string }} TestRunnerOptions
+ */
+
+/**
+ * @typedef {{
+ *  name: string;
+ *  start?: number;
+ *  end?: number;
+ *  status?: "pass" | "fail";
+ *  result?: any;
+ *  error?: any;
+ * }} TestResult
+ */
+
+/**
+ * @typedef {{ only: boolean; skip: boolean; name: string; callback: () => any }} SuiteDefinition
+ */
+
+/**
+ * @typedef {{ only?: boolean; skip?: boolean; name?: string; tests: TestResult[]; time?: number }} SuiteResult
+ */
+
+/**
+ * @typedef {{
+ *  toEqual: (value: any, unit?: string) => void;
+ *  toBeLessThan: (value: any, unit?: string) => void;
+ *  toBeGreaterThan: (value: any, unit?: string) => void;
+ *  toInclude: (value: any) => void;
+ *  toMatch: (regex: string | RegExp) => void;
+ *  toThrow: (message?: string) => void;
+ * }} ExpectMatcherSet
+ */
+
+/**
+ * @typedef {ExpectMatcherSet & { not: ExpectMatcherSet }} ExpectMatchers
+ */
+
+export class TestRunner {
+  /** @type {TestRunnerOptions} */
+  #options = {};
+  /** @type {SuiteDefinition[]} */
+  #suites = [];
+  /** @type {SuiteResult[]} */
+  #results;
+  /** @type {SuiteResult | null} */
+  #active;
+  /** @type {number} */
+  #running;
+
+  /**
+   * @param {TestRunnerOptions} [options]
+   */
+  constructor(options = {}) {
+    this.#options = options;
+    this.suite = this.#suite.bind(this);
+    this.suite.only = (name, callback) => this.#suite(name, callback, { only: true });
+    this.suite.skip = (name, callback) => this.#suite(name, callback, { skip: true });
+    this.test = this.#test.bind(this);
+    this.test.only = (name, callback) => this.#test(name, callback, { only: true });
+    this.test.skip = (name, callback) => this.#test(name, callback, { skip: true });
+  }
+
+  /**
+   * @returns {Promise<SuiteResult[]>}
+   */
+  async run() {
+    this.#running = 0;
+    this.#results = [];
+    for (const suite of this.#suites) {
+      this.#active = { only: suite.only, name: suite.name, skip: suite.skip, tests: [] };
+      try {
+        await suite.callback();
+      } catch {
+        /* Do Nothing */
+      }
+      this.#results.push(this.#active);
+      this.#active = null;
+    }
+    while (this.#running > 0) await new Promise((resolve) => setTimeout(resolve, 100));
+    return this.#results;
+  }
+
+  /**
+   * @param {string} name
+   * @param {() => any} callback
+   * @param {{ only?: boolean, skip?: boolean }} options
+   * @returns {Promise<void>}
+   */
+  async #suite(name, callback, { only, skip } = {}) {
+    if (this.#active) throw new Error("Suites cannot be stacked");
+    this.#suites.push({ only, skip, name, callback });
+  }
+
+  /**
+   * @param {string} name
+   * @param {() => any | Promise<any>} callback
+   * @param {{ only?: boolean, skip?: boolean }} options
+   * @returns {Promise<void>}
+   */
+  async #test(name, callback, { only, skip } = {}) {
+    if (
+      (this.#options.filter && !name.match(new RegExp(this.#options.filter, "i"))) ||
+      (this.#options.only && !(only || this.#active?.only))
+    )
+      return;
+    const test = { name };
+    if (skip || this.#active?.skip) {
+      test.status = "skip";
+      this.#active?.tests.push(test);
+      return;
+    } else this.#running++;
+    test.start = performance();
+    if (this.#active) this.#active.tests.push(test);
+    else this.#results.push({ tests: [test], time: test.time });
+    try {
+      test.result = await callback();
+      test.status = "pass";
+      test.end = performance();
+    } catch (error) {
+      test.status = "fail";
+      test.error = error;
+      test.end = performance();
+    }
+    this.#running--;
+  }
+
+  /**
+   * @param {any} target
+   * @param {string} [label]
+   * @returns {ExpectMatchers}
+   */
+  expect(target, label) {
+    return {
+      not: {
+        toEqual: (value, unit = "") => {
+          if (target !== value) return;
+          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not equal ${value}${unit}`);
+        },
+        toBeLessThan: (value, unit = "") => {
+          if (target >= value) return;
+          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not be less than ${value}${unit}`);
+        },
+        toBeGreaterThan: (value, unit = "") => {
+          if (target <= value) return;
+          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not be greater than ${value}${unit}`);
+        },
+        toInclude: (value) => {
+          if (target.indexOf(value) === -1) return;
+          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not include ${value}`);
+        },
+        toMatch: (regex) => {
+          if (!target.match(new RegExp(regex))) return;
+          throw new Error(`expected ${label ? label + "(" + target + ")" : target} to not match ${regex}`);
+        },
+        toThrow: (message) => {
+          try {
+            target();
+          } catch (error) {
+            if (!message)
+              throw new Error(`expected ${label ? label + "()" : "function()"} to not throw, but got ${error.message}`);
+            if (error.message === message)
+              throw new Error(
+                `expected ${label ? label + "()" : "function()"} to not throw ${message}, but got ${error.message}`,
+              );
+            if (error.message.match(new RegExp(message)))
+              throw new Error(
+                `expected ${label ? label + "()" : "function()"} to not throw ${message}, but got ${error.message}`,
+              );
+            return;
+          }
+        },
+      },
+      toEqual: (value, unit = "") => {
+        if (target === value) return;
+        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to equal ${value}${unit}`);
+      },
+      toBeLessThan: (value, unit = "") => {
+        if (target < value) return;
+        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to be less than ${value}${unit}`);
+      },
+      toBeGreaterThan: (value, unit = "") => {
+        if (target > value) return;
+        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to be greater than ${value}${unit}`);
+      },
+      toInclude: (value) => {
+        if (target.indexOf(value) > -1) return;
+        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to include ${value}`);
+      },
+      toMatch: (regex) => {
+        if (target.match(new RegExp(regex))) return;
+        throw new Error(`expected ${label ? label + "(" + target + ")" : target} to match ${regex}`);
+      },
+      toThrow: (message) => {
+        try {
+          target();
+        } catch (error) {
+          if (!message) return;
+          if (error.message === message) return;
+          if (error.message.match(new RegExp(message))) return;
+          throw new Error(`expected ${label ? label + "()" : "function()"} to throw ${message}, but got ${error.message}`);
+        }
+      },
+    };
+  }
+}
+
+function performance() {
+  return globalThis.performance.now();
+}

package/commands/bundle.js

@@ -1,19 +1,20 @@
 import { resolve } from "node:path";
 import { Bundler } from "../classes/bundler.js";
 import { Runtime } from "../classes/runtime.js";
+import { parseArgs } from "../utils.js";
 import DefaultCommand from "./default.js";
 
 export default class BundlerCommand extends DefaultCommand {
-  help() {
+  async help() {
     console.print("Bundles the specified entry file");
     console.print("\nUsage:");
     console.print("vistta bundle [filename] [outdir]\tBundles the specified entry file");
   }
 
   async main(_, ...argv) {
-    let [args, options] = this.parse(argv);
+    let [args, options] = parseArgs(argv);
     if (args.length === 0) return this.help();
-    options = Object.assign({}, this.options, options, { outdir: args[1] });
+    options = Object.assign({}, process.vistta?.options?.bundler || {}, options, { outdir: args[1] });
     new Bundler(new Runtime(global.vistta)).run(resolve(process.cwd(), args[0]), options);
   }
 }