@vistta/cli 1.0.1

package/classes/command.js

@@ -0,0 +1,70 @@
+/* eslint-disable no-unused-vars */
+/**
+ * @define {Object} LoaderConfig
+ * @property {string} main The path to the module exporting the loader class
+ * @property {string} [type] The import attribute type that the loader supports
+ * @property {string} [filter] A filter to match against the specifier
+ */
+
+export class Command {
+  #loaders = [];
+  #resolvers = ["js"];
+
+  get loaders() {
+    return this.#loaders;
+  }
+
+  get resolvers() {
+    return this.#resolvers;
+  }
+
+  /**
+   * Optional method to display help about the plugin.
+   * @param {...string} args
+   */
+  help(...args) {
+    // Optional: subclasses may implement if needed
+  }
+
+  /**
+   * Main method to execute the plugin.
+   * @abstract
+   * @param {...string} args
+   */
+  main(...args) {
+    throw new Error("Method 'main' must be implemented.");
+  }
+
+  /**
+   * Registers a new loader.
+   * @param {string} path - The path to the module exporting the loader class
+   * @param {Object} [options] - The loader options
+   * @param {string} [options.type] - The import attribute type that the loader supports
+   * @param {string} [options.filter] - A filter to match against the specifier
+   */
+  register(path, options = {}) {
+    this.#loaders.push({ main: path, ...options });
+  }
+
+  /**
+   * Adds new file extensions to resolve without needing to specify them.
+   * @param {...string} extensions - The file extensions to add (without the dot)
+   */
+  resolve(...extensions) {
+    this.#resolvers.push(...extensions);
+  }
+
+  /**
+   * Defines either an environment variable or a global variable.
+   * @param {"global"|"env"} type - Either environment or global.
+   * @param {string} key - The key.
+   * @param {any} value - The value.
+   */
+  define(type, key, value) {
+    if (type === "env") process.env[key] = value?.toString() ?? "";
+    else if (type === "global") global[key] = value;
+    else throw new Error(`Unknown define type "${type}"`);
+  }
+}
+
+export default Command;

package/classes/loader.js

@@ -0,0 +1,15 @@
+/* eslint-disable no-unused-vars */
+export class Loader {
+  constructor() {}
+
+  /**
+   * Main method to execute the loader.
+   * @abstract
+   * @param {string} source The source code to load/process
+   * @param {Object} properties Properties for the loader
+   */
+  load(source, properties) {
+    throw new Error("Method 'load' must be implemented.");
+  }
+}
+export default Loader;

package/classes/runtime.js

@@ -0,0 +1,154 @@
+import fs from "@vistta/fs";
+import { isBuiltin } from "node:module";
+import { fileURLToPath, pathToFileURL, URLSearchParams } from "node:url";
+import { Loader } from "./loader.js";
+
+const CWD = process.cwd();
+const FALLBACK = "*";
+
+export class Runtime {
+  static Error = class extends Error {
+    constructor(name, message) {
+      super(message);
+      this.name = name + " Loader Error";
+    }
+  };
+
+  #init;
+  #loaders;
+  #resolvers;
+  #options;
+
+  get loaders() {
+    return this.#loaders;
+  }
+
+  get options() {
+    return this.#options;
+  }
+
+  constructor({ loaders, resolvers, options }) {
+    this.#init = async () => {
+      this.#loaders = {};
+      for (let i = 0, len = loaders?.length || 0; i < len; i++) {
+        let { main, type, filter } = loaders[i];
+        const { default: LoaderClass } = await import(main);
+        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] = {};
+        this.#loaders[type][filter || FALLBACK] = new LoaderClass(options);
+      }
+    };
+    this.#resolvers = resolvers;
+    this.#options = options;
+  }
+
+  async resolve(specifier, context, nextResolve, options) {
+    if (!this.#loaders) await this.#init();
+    [specifier, options] = specifier.split(/\?(.*)/);
+    options = new URLSearchParams(options);
+    const { parentURL = CWD, conditions: [type] = [] } = context;
+    if (isBuiltin(specifier)) {
+      if (type === "bundler") context.builtin = true;
+      return nextResolve(specifier, context);
+    }
+
+    const paths = this.#options?.compiler?.paths || {};
+    const pathKeys = Object.keys(paths);
+    for (let i = 0, len = pathKeys.length; i < len; i++) {
+      const cur = pathKeys[i];
+      const resolved = paths[cur][0];
+      if (cur.endsWith("*")) {
+        const regex = cur.slice(0, -1);
+        if (new RegExp(`^${regex}.*`).test(specifier) && resolved.endsWith("*")) {
+          specifier = fs.resolve(CWD + "/", resolved.slice(0, -1), specifier.replace(new RegExp(`^${regex}`), ""));
+          break;
+        }
+      } else if (cur === specifier) {
+        specifier = fs.resolve(CWD + "/", resolved);
+        break;
+      }
+    }
+
+    if (!/^(\w:|\.?\.?\/)/.test(specifier)) return nextResolve(specifier, context);
+    if (specifier?.startsWith("file://")) specifier = fileURLToPath(specifier);
+
+    if (!fs.isAbsolute(specifier))
+      specifier = fs.resolve(parentURL?.startsWith("file://") ? fs.dirname(parentURL) : parentURL, specifier);
+    const len = this.#resolvers.length;
+    if (fs.existsSync(specifier)) {
+      if (fs.isDirectory(specifier)) {
+        for (let i = 0; i < len; i++) {
+          const cur = fs.resolve(specifier, `index.${this.#resolvers[i]}`);
+          if (fs.existsSync(cur)) {
+            specifier = cur;
+            break;
+          }
+        }
+      }
+    } else
+      for (let i = 0; i < len; i++) {
+        const cur = specifier + `.${this.#resolvers[i]}`;
+        if (fs.existsSync(cur)) {
+          specifier = cur;
+          break;
+        }
+      }
+
+    if (type === "bundler") {
+      if (fs.isAbsolute(specifier)) context.file = true;
+      return nextResolve(specifier, context);
+    }
+
+    const params = options.toString();
+    specifier = pathToFileURL(specifier).href;
+    if (params.length > 0) return nextResolve(`${specifier}?${params}`, context);
+    return nextResolve(specifier, 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 loader = match(this.#loaders, path, options.type);
+    if (!loader) return nextLoad(url, context);
+    options.path = path;
+    options.extension = fs.extname(url).slice(1);
+    const {
+      code,
+      warnings,
+      errors,
+      resources,
+      files = [],
+    } = await loader.load.call(this, await fs.readFile(path, "utf-8"), options);
+    if (!code)
+      await loader.load.call(this, await fs.readFile(path, "utf-8"), {
+        ...options,
+        debug: true,
+      });
+    if (errors?.length) throw new Runtime.Error(loader.name || loader.constructor.name, `${errors.join("\n")}`);
+    warnings?.forEach((warning) => console.warn(`${loader.name || loader.constructor.name} Loader Warning: ${warning}\n`));
+    return {
+      format: "module",
+      shortCircuit: true,
+      source: code,
+      resources: resources,
+      files: [options.path, ...files.map((url) => fileURLToPath(url))],
+    };
+  }
+}
+
+function match(loaders, path, type = FALLBACK) {
+  if (type === FALLBACK && new RegExp(`^.*\\.(js|mjs|cjs)$`).test(path)) return null;
+  const patterns = Object.keys(loaders[type] || {});
+  let fallback = null;
+  for (let i = 0, len = patterns.length; i < len; i++) {
+    const pattern = patterns[i];
+    if (pattern === FALLBACK) fallback = pattern;
+    else if (new RegExp(`^${pattern}$`).test(path)) return loaders[type][pattern];
+  }
+  if (fallback) return loaders[type][fallback];
+  if (path === FALLBACK) return null;
+  return match(loaders, FALLBACK, type);
+}

package/commands/bundle.js

@@ -0,0 +1,19 @@
+import { resolve } from "node:path";
+import { Bundler } from "../classes/bundler.js";
+import { Runtime } from "../classes/runtime.js";
+import DefaultCommand from "./default.js";
+
+export default class BundlerCommand extends DefaultCommand {
+  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);
+    if (args.length === 0) return this.help();
+    options = Object.assign({}, this.options, options, { outdir: args[1] });
+    new Bundler(new Runtime(global.vistta)).run(resolve(process.cwd(), args[0]), options);
+  }
+}

package/commands/default.js

@@ -0,0 +1,49 @@
+import { COLORS } from "@vistta/console";
+import fs from "@vistta/fs";
+import { Command } from "../classes/command.js";
+
+const dirname = import.meta.dirname;
+
+export default class DefaultCommand extends Command {
+  constructor() {
+    super();
+    this.register(fs.resolve(dirname, "../loaders/file.js"));
+    this.register(fs.resolve(dirname, "../loaders/typescript.js"), { filter: ".*\\.(ts|mts|cts)" });
+    this.register(fs.resolve(dirname, "../loaders/json.js"), { filter: ".*\\.json" });
+    this.register(fs.resolve(dirname, "../loaders/bundler.js"), { type: "bundler" });
+    this.resolve("ts");
+  }
+
+  async help() {
+    console.print("vistta <command/script>\n\nAvailable commands:");
+    const commands = Object.keys(process.vistta.options.cli.commands);
+    let output = "\n\t";
+    for (let i = 0, len = commands.length; i < len; i++) {
+      if (commands[i] !== "default") output += commands[i] + (i < len - 1 ? ", " : "");
+    }
+    console.print(output);
+  }
+
+  async main(file) {
+    if (process.env.NODE_ENV === "development") await this.outdated();
+    const filepath = fs.resolve(process.cwd(), file);
+    if (!fs.existsSync(filepath)) {
+      console.print(`Unknown command/script "${file}"\n`);
+      return this.help();
+    }
+    import(filepath);
+  }
+
+  async outdated() {
+    try {
+      const modules = await (await import("../utils.js"))?.getOutdatedPackages(process.cwd());
+      for (let i = 0, len = modules.length; i < len; i++) {
+        const { name, current, wanted, latest } = modules[i];
+        if (current === wanted) console.print(`${COLORS.CYAN}Module "${name}" has a new version (${latest})${COLORS.RESET}`);
+        else console.print(`${COLORS.YELLOW}Module "${name}" is outdated (${latest})${COLORS.RESET}`);
+      }
+    } catch {
+      console.print(`${COLORS.YELLOW}Failed to verify modules${COLORS.RESET}`);
+    }
+  }
+}

package/commands/project.js

@@ -0,0 +1,101 @@
+import { COLORS } from "@vistta/console";
+import fs from "@vistta/fs";
+import { capitalize } from "@vistta/utils";
+import { Command } from "../classes/command.js";
+import { getOutdatedPackages, importJSON, incrementPackageVersion } from "../utils.js";
+
+const HELP = {
+  name: "outputs current project name",
+  version: "outputs the project version",
+  "version [increment]": "updates the project version",
+  outdated: "lists all outdated modules in the project",
+  patch: "updates the version of outdated modules to the latest patch version in the project",
+  "patch [module]": "updates the version of outdated module to the latest patch version in the project",
+  update: "updates the version of outdated modules to the latest version in the project",
+  "update [module]": "updates the version of outdated module to the latest version in the project",
+};
+
+export default class extends Command {
+  constructor(options) {
+    super(options);
+  }
+
+  help(_, command) {
+    switch (command) {
+      case "name":
+        console.print(capitalize(HELP["name"]));
+        console.print("\nUsage:");
+        console.print("vistta project name");
+        break;
+      case "version":
+        console.print(capitalize(HELP["version"]) + " or " + HELP["version [increment]"]);
+        console.print("\nUsage:");
+        console.print("vistta project version");
+        console.print("vistta project version [increment]");
+        break;
+      case "outdated":
+        console.print(capitalize(HELP["outdated"]));
+        console.print("\nUsage:");
+        console.print("vistta project outdated");
+        break;
+      case "patch":
+        console.print(capitalize(HELP["patch"]) + " or " + HELP["patch [module]"]);
+        console.print("\nUsage:");
+        console.print("vistta project patch");
+        console.print("vistta project patch [module]");
+        break;
+      case "update":
+        console.print(capitalize(HELP["update"]) + " or " + HELP["update [module]"]);
+        console.print("\nUsage:");
+        console.print("vistta project update");
+        console.print("vistta project update [module]");
+        break;
+      default:
+        console.print("Outputs the current project name or version, or updates the version");
+        console.print("\nUsage:");
+        Object.keys(HELP).forEach((key) => console.print(`vistta project ${key}\t\t\t${HELP[key]}`));
+        break;
+    }
+  }
+
+  async main(_, command, ...args) {
+    console.clear();
+    switch (command) {
+      case "name":
+        return console.print(process.env.PROJECT_NAME);
+      case "version":
+        if (!args[0]) return console.print(process.env.PROJECT_VERSION);
+        return console.print(
+          await incrementPackageVersion(fs.resolve(process.env.PROJECT_PATH, "package.json"), args[0], args[1]),
+        );
+      case "outdated":
+      case "patch":
+      case "update":
+        return modules(command, args[0]);
+    }
+    return this.help(_, command);
+  }
+}
+
+async function modules(command, arg1) {
+  const modules = await getOutdatedPackages(process.cwd());
+  let valid = true;
+  let update = 0;
+  for (let i = 0, len = modules.length; i < len; i++) {
+    const { name, package: packagePath, current, wanted, latest, dev } = modules[i];
+    if (command === "patch" || command === "update") {
+      if (command === "patch" && current === wanted) continue;
+      if (arg1 && name !== arg1) continue;
+      const packageObj = await importJSON(packagePath);
+      packageObj[dev ? "devDependencies" : "dependencies"][name] = "^" + (command === "patch" ? wanted : latest);
+      await fs.writeFile(packagePath, JSON.stringify(packageObj, null, 2));
+      update++;
+    } else if (current === wanted)
+      console.print(`${COLORS.CYAN}Module "${name}" has a new version (${latest})${COLORS.RESET}`);
+    else (console.print(`${COLORS.YELLOW}Module "${name}" is outdated (${latest})${COLORS.RESET}`), (valid = false));
+  }
+
+  if (modules.length == 0) console.print("Everything is up to date");
+  else if (update > 0) console.print(`Updated ${update} module${update > 1 ? "s" : ""} versions in project package.`);
+  process.exit(valid ? 0 : -1);
+}

package/commands/test.js

@@ -0,0 +1,214 @@
+import { COLORS } from "@vistta/console";
+import fs from "@vistta/fs";
+import { parseArgs } from "../utils.js";
+import DefaultCommand from "./default.js";
+
+const cwd = process.cwd();
+
+export default class extends DefaultCommand {
+  #options = {};
+  #results = [];
+  #failed;
+  #suite;
+  #runningCounter = 0;
+
+  constructor() {
+    super();
+    const suite = this.suite.bind(this, false);
+    suite.only = this.suite.bind(this, true);
+    this.define("env", "NODE_ENV", "testing");
+    this.define("global", "suite", suite);
+    const test = this.test.bind(this, false);
+    test.only = this.test.bind(this, true);
+    this.define("global", "test", test);
+    this.define("global", "expect", this.expect.bind(this));
+  }
+
+  help() {
+    console.print("Runs all the tests files that match the pattern/s in the current project");
+    console.print("\nUsage:");
+    console.print("vistta test [...patterns]\tRuns all the tests files that match the pattern/s in the current project");
+    console.print(
+      'vistta test --filter="pattern"\tRuns all the tests that match the filter pattern/s in the current project',
+    );
+    console.print("vistta test --only\tRuns all the tests that have the only");
+  }
+
+  async main(_, ...argv) {
+    let [args, options] = parseArgs(argv);
+    this.#options = options;
+    if (args.length === 0) args = ["**/*.test.js", "**/*.test.ts"];
+    for (let i = 0, len = args.length; i < len; i++) args[i] = fs.resolve(cwd, args[i]);
+    const entries = fs.glob(args);
+    let entry = (await entries.next())?.value;
+    if (!process.env.NODE_DEBUG) console.disable();
+    while (entry) {
+      try {
+        process.chdir(fs.dirname(entry));
+        if (!entry.includes("\\node_modules\\")) await import(fs.resolve(entry));
+        await this.#await();
+      } catch {
+        this.#failed = true;
+      }
+      entry = (await entries.next())?.value;
+    }
+    if (!process.env.NODE_DEBUG) console.enable();
+    let output = "";
+    for (let i = 0, len = this.#results.length; i < len; i++) {
+      const { name, tests } = this.#results[i];
+      if (name) output += `\n${name}\n`;
+      const [results, passing, total, time] = processTests(tests);
+      output += `${results}${passing === total ? COLORS.GREEN : COLORS.RED}${passing}/${total} passing ${COLORS.RESET + COLORS.DIM}(${time}ms)${COLORS.RESET}\n`;
+    }
+    console.print(output);
+    process.exit(this.#failed ? -1 : 0);
+  }
+
+  async suite(only, name, callback) {
+    if (this.#suite) throw new Error("Suites/Describes cannot be stacked");
+    this.#runningCounter++;
+    this.#suite = { name, only, tests: [] };
+    try {
+      const value = callback();
+      if (value instanceof Promise) await value;
+    } catch {
+      /* Do Nothing */
+    }
+    this.#results.push(this.#suite);
+    this.#suite = null;
+    this.#runningCounter--;
+  }
+
+  async test(only, name, callback) {
+    if (
+      (this.#options.filter && !name.match(new RegExp(this.#options.filter, "i"))) ||
+      (this.#options.only && !(only || this.#suite?.only))
+    )
+      return;
+    this.#runningCounter++;
+    const test = { name };
+    test.start = performance();
+    if (this.#suite) this.#suite.tests.push(test);
+    else this.#results.push({ tests: [test], time: test.time });
+
+    try {
+      test.result = callback();
+      if (test.result instanceof Promise) test.result = await test.result;
+      test.status = "pass";
+      test.end = performance();
+    } catch (error) {
+      test.status = "fail";
+      test.error = error;
+      test.end = performance();
+      this.#failed = true;
+    }
+    this.#runningCounter--;
+  }
+
+  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}`);
+        }
+      },
+    };
+  }
+
+  #await() {
+    return new Promise((resolve) => {
+      const timer = () => {
+        if (this.#runningCounter === 0) resolve();
+        else setTimeout(timer, 500);
+      };
+      timer();
+    });
+  }
+}
+
+function processTests(tests) {
+  let passing = 0;
+  let total = 0;
+  let acc = "";
+  let first, last;
+  for (let i = 0, len = tests?.length || 0; i < len; i++) {
+    const { name, status, start, end, result, error } = tests[i];
+    if (!first || start < first) first = start;
+    if (!last || end > last) last = end;
+    if (status === "pass") {
+      acc += `  ${COLORS.GREEN}✔  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n${typeof result === "string" ? "\t" + COLORS.GREEN + result + COLORS.RESET + "\n" : ""}`;
+      passing++;
+    } else
+      acc += `  ${COLORS.RED}✖  ${name} ${COLORS.RESET + COLORS.DIM}(${Math.round(end - start)}ms)${COLORS.RESET}\n\t${COLORS.RED + error + COLORS.RESET}\n`;
+    total++;
+  }
+  return [acc, passing, total, Math.round(last - first)];
+}
+
+function performance(time = process.hrtime()) {
+  return time[0] * 1000 + time[1] / 1e6;
+}

package/global.d.ts

@@ -0,0 +1 @@
+/// <reference path="@vistta/console" />

package/index.js

@@ -0,0 +1,9 @@
+export { Bundler } from "./classes/bundler.js";
+export { Command } from "./classes/command.js";
+export { Loader } from "./classes/loader.js";
+export { Runtime } from "./classes/runtime.js";
+export { default as BundleCommand } from "./commands/bundle.js";
+export { default as DefaultCommand } from "./commands/default.js";
+export { default as ProjectCommand } from "./commands/project.js";
+export { default as TestCommand } from "./commands/test.js";
+export { parseArgs } from "./utils.js";

package/loaders/bundler.js

@@ -0,0 +1,20 @@
+import { Bundler } from "../classes/bundler.js";
+import { Loader } from "../index.js";
+import { remove } from "../utils.js";
+
+export default class BundlerLoader extends Loader {
+  async load(_, { path, ...options }) {
+    options.write = false;
+    remove(options, "type", "extension");
+    const { code, files, resources, errors, warnings } = await new Bundler(this).run(path, options);
+    return {
+      code:
+        `export const code = ${JSON.stringify(code)}; ` +
+        `export const files = ${JSON.stringify(files)}; ` +
+        `export const resources = ${JSON.stringify(resources)}; ` +
+        `export const errors = ${JSON.stringify(errors)}; ` +
+        `export const warnings = ${JSON.stringify(warnings)};`,
+      resources: resources,
+    };
+  }
+}

package/loaders/file.js

@@ -0,0 +1,12 @@
+import fs from "@vistta/fs";
+import { Loader } from "../index.js";
+
+export default class FileLoader extends Loader {
+  async load(_, { path, encoding }) {
+    const urlHash = fs.fileId(path) + fs.extname(path);
+    return {
+      code: `export default ${JSON.stringify(await fs.readFile(path, encoding || "utf8"))}`,
+      resources: [{ path, hash: urlHash }],
+    };
+  }
+}