@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-6e4fqv30.js

@@ -0,0 +1,588 @@
+// @bun
+import {
+  build
+} from "./index-cjgqs13g.js";
+import {
+  setConfig
+} from "./index-jks0x0a1.js";
+import {
+  emitBuildFeatureUsageTelemetry,
+  emitSessionStartedTelemetry
+} from "./index-6b009mt0.js";
+import {
+  PHASE_DEVELOPMENT_SERVER,
+  PHASE_PRODUCTION_BUILD
+} from "./index-4zzebszd.js";
+import {
+  collectImagesConfigErrors
+} from "./index-sq3kvz3g.js";
+import {
+  setSvgAsComponentEnabled,
+  webpackReferencesSvgr
+} from "./index-ckkdpht5.js";
+import {
+  setCacheComponents
+} from "./index-kresp2n8.js";
+
+// src/compat/next/config-loader.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+
+// src/compat/mdx/stub.ts
+var NEXT_MDX_STUB_CONTENTS = `
+const createMDX = (pluginOptions = {}) => (nextConfig = {}) => ({
+  ...nextConfig,
+  mdxOptions: (pluginOptions && pluginOptions.options) || {},
+});
+module.exports = createMDX;
+module.exports.default = createMDX;
+`;
+function nextMdxConfigStubPlugin() {
+  return {
+    name: "pnext-next-mdx-config-stub",
+    setup(build2) {
+      build2.onResolve({ filter: /^@next\/mdx(?:\/|$)/ }, (args) => ({
+        path: args.path,
+        namespace: "pnext-next-mdx-stub"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "pnext-next-mdx-stub" }, () => ({
+        contents: NEXT_MDX_STUB_CONTENTS,
+        loader: "js"
+      }));
+    }
+  };
+}
+
+// src/compat/next/config-loader.ts
+var CONFIG_BASENAMES = [
+  "next.config.ts",
+  "next.config.mts",
+  "next.config.cts",
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.cjs"
+];
+var store = {};
+var storeReleased = false;
+function nextConfigReleased() {
+  return storeReleased;
+}
+function getNextConfig() {
+  return store;
+}
+function readCacheComponentsFlag(config) {
+  if (process.env.__NEXT_CACHE_COMPONENTS === "true")
+    return true;
+  if (config.cacheComponents === true)
+    return true;
+  const experimental = config.experimental;
+  if (experimental?.cacheComponents === true)
+    return true;
+  if (experimental?.dynamicIO === true)
+    return true;
+  return false;
+}
+function setNextConfig(config) {
+  store = config;
+  setCacheComponents(readCacheComponentsFlag(config));
+  setSvgAsComponentEnabled(webpackReferencesSvgr(config));
+  globalThis.__PNEXT_BASE_PATH__ = typeof config.basePath === "string" ? config.basePath : "";
+  globalThis.__PNEXT_SKIP_TRAILING_SLASH__ = config.skipTrailingSlashRedirect === true;
+  globalThis.__PNEXT_TRAILING_SLASH__ = config.trailingSlash === true;
+}
+function findConfigPath(root) {
+  for (const name of CONFIG_BASENAMES) {
+    const candidate = path.join(root, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return;
+}
+var { Bun: bun } = globalThis;
+function configSourceKey(configPath) {
+  try {
+    return bun.hash(readFileSync(configPath)).toString(36);
+  } catch {
+    return "config";
+  }
+}
+function findTsconfig(root) {
+  const candidate = path.join(root, "tsconfig.json");
+  return existsSync(candidate) ? candidate : undefined;
+}
+async function importConfigModule(configPath, root, options) {
+  const cjs = cjsConfigFormat(configPath, root);
+  if (process.env.PNEXT_CONFIG_FAST !== "0" && selfContainedConfig(configPath)) {
+    if (cjs)
+      return createRequire(pathToFileURL(configPath))(configPath);
+    const module = await import(pathToFileURL(configPath).href);
+    return module.default ?? {};
+  }
+  const outDir = path.join(root, ".pnext", ...options.dev ? ["dev"] : [], "config");
+  const outfile = path.join(outDir, `next.config.${configSourceKey(configPath)}.${cjs ? "cjs" : "mjs"}`);
+  if (options.serve && existsSync(outfile))
+    return importConfigBundle(outfile, cjs);
+  try {
+    mkdirSync(outDir, { recursive: true });
+    await bundleConfig({ configPath, root, outDir, outfile, cjs });
+  } catch (error) {
+    if (!options.serve)
+      throw error;
+    throw new Error(`pnext: ${path.relative(root, outfile)} is missing and could not be rebuilt here \u2014 run ` + "`pnext build` and deploy its output dir, which carries the config bundle. Cause: " + (error instanceof Error ? error.message : String(error)), { cause: error });
+  }
+  pruneStaleConfigBundles(outDir, outfile);
+  return importConfigBundle(outfile, cjs);
+}
+async function emitNextConfigBundle(root, outDir) {
+  const configPath = findConfigPath(root);
+  if (!configPath)
+    return;
+  const cjs = cjsConfigFormat(configPath, root);
+  const [file, ...handlerFiles] = await Promise.all([
+    hashedOutput(outDir, "next.config", cjs ? ".cjs" : ".mjs", (outfile) => bundleConfig({ configPath, root, outDir, outfile, cjs, relocatable: true })),
+    ...cacheHandlerFiles(store).map(([name, source]) => hashedOutput(outDir, name, ".cjs", (outfile) => build({
+      entryPoints: [source],
+      outfile,
+      bundle: true,
+      platform: "node",
+      format: "cjs",
+      target: "esnext",
+      packages: "external",
+      logLevel: "silent"
+    })).then((output) => [name, output]))
+  ]);
+  return { file, handlers: Object.fromEntries(handlerFiles) };
+}
+async function hashedOutput(outDir, name, ext, emit) {
+  const temporary = path.join(outDir, `${name}.${process.pid}.tmp${ext}`);
+  await emit(temporary);
+  const hash = bun.hash(readFileSync(temporary)).toString(36);
+  const outfile = path.join(outDir, `${name}.${hash}${ext}`);
+  renameSync(temporary, outfile);
+  return outfile;
+}
+function cacheHandlerFiles(config) {
+  const handlers = config.cacheHandlers;
+  return [
+    ["cache-handler", config.cacheHandler],
+    [
+      "cache-handler-default",
+      handlers && typeof handlers === "object" ? handlers.default : undefined
+    ]
+  ].filter((entry) => typeof entry[1] === "string" && path.isAbsolute(entry[1]) && existsSync(entry[1]));
+}
+function releasedCacheHandlers(config, handlers) {
+  const handler = handlers["cache-handler"];
+  const fallback = handlers["cache-handler-default"];
+  return {
+    ...config,
+    ...handler ? { cacheHandler: handler } : {},
+    ...fallback ? { cacheHandlers: { ...config.cacheHandlers, default: fallback } } : {}
+  };
+}
+var toPosix = (file) => file.split(path.sep).join("/");
+function bundleConfig({
+  configPath,
+  root,
+  outDir,
+  outfile,
+  cjs,
+  relocatable = false
+}) {
+  const configUrl = relocatable ? `new URL(${JSON.stringify(toPosix(path.relative(outDir, configPath)))}, ${cjs ? '__pnextNodeRequire("node:url").pathToFileURL(__filename)' : "import.meta.url"}).href` : JSON.stringify(pathToFileURL(configPath).href);
+  return build({
+    entryPoints: [configPath],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: cjs ? "cjs" : "esm",
+    target: "esnext",
+    packages: "external",
+    plugins: [nextDistStubPlugin(outDir), nextMdxConfigStubPlugin()],
+    banner: cjs ? {
+      js: `var __pnextNodeRequire = module.require.bind(module);
+var __pnextConfigUrl = ${configUrl};
+var __pnextConfigFile = __pnextNodeRequire("node:url").fileURLToPath(__pnextConfigUrl);
+var __pnextConfigDir = __pnextNodeRequire("node:path").dirname(__pnextConfigFile);
+var require = __pnextNodeRequire("node:module").createRequire(__pnextConfigUrl);`
+    } : {
+      js: `import { createRequire as __pnextCreateRequire } from "node:module";
+import { fileURLToPath as __pnextFileURLToPath } from "node:url";
+import { dirname as __pnextDirname } from "node:path";
+const __pnextConfigUrl = ${configUrl};
+const __pnextConfigFile = __pnextFileURLToPath(__pnextConfigUrl);
+const __pnextConfigDir = __pnextDirname(__pnextConfigFile);
+const require = __pnextCreateRequire(__pnextConfigUrl);`
+    },
+    tsconfig: findTsconfig(root),
+    define: {
+      __dirname: "__pnextConfigDir",
+      __filename: "__pnextConfigFile",
+      "import.meta.url": "__pnextConfigUrl"
+    },
+    logLevel: "silent",
+    sourcemap: false,
+    metafile: false
+  });
+}
+async function importConfigBundle(outfile, cjs) {
+  if (cjs)
+    return createRequire(pathToFileURL(outfile))(outfile);
+  const module = await import(pathToFileURL(outfile).href);
+  return module.default ?? {};
+}
+function pruneStaleConfigBundles(outDir, outfile) {
+  try {
+    for (const entry of readdirSync(outDir)) {
+      if (!/^next\.config\..+\.[cm]js$/.test(entry))
+        continue;
+      if (path.join(outDir, entry) === outfile)
+        continue;
+      rmSync(path.join(outDir, entry), { force: true });
+    }
+  } catch {}
+}
+function selfContainedConfig(configPath) {
+  try {
+    const source = readFileSync(configPath, "utf8").replaceAll("import.meta", "");
+    return !/\b(?:import|require|__dirname|__filename)\b/.test(source);
+  } catch {
+    return false;
+  }
+}
+function cjsConfigFormat(configPath, root) {
+  if (configPath.endsWith(".cjs") || configPath.endsWith(".cts"))
+    return true;
+  if (!configPath.endsWith(".js"))
+    return false;
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    return pkg.type !== "module";
+  } catch {
+    return true;
+  }
+}
+var NEXT_DIST_STUB_CONTENTS = `class PNextConfigStub {}
+module.exports = new Proxy(PNextConfigStub, { get: (t, k) => (k === "default" ? PNextConfigStub : t[k] ?? PNextConfigStub) });
+`;
+function nextDistStubPlugin(outDir) {
+  return {
+    name: "pnext-next-dist-stub",
+    setup(build2) {
+      build2.onResolve({ filter: /^next\/dist\// }, (args) => {
+        if (args.kind === "require-resolve") {
+          const stubPath = path.join(outDir, "next-dist-stub", `${args.path}.cjs`);
+          mkdirSync(path.dirname(stubPath), { recursive: true });
+          writeFileSync(stubPath, NEXT_DIST_STUB_CONTENTS);
+          return { path: stubPath, external: true };
+        }
+        return { path: args.path, namespace: "pnext-next-dist-stub" };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "pnext-next-dist-stub" }, () => ({
+        contents: NEXT_DIST_STUB_CONTENTS,
+        loader: "js"
+      }));
+    }
+  };
+}
+function currentPhase(dev) {
+  return dev ? PHASE_DEVELOPMENT_SERVER : PHASE_PRODUCTION_BUILD;
+}
+function isModuleNotFoundError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const code = error.code;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND")
+    return true;
+  const message = error.message;
+  return typeof message === "string" && /Cannot find (?:module|package)/.test(message);
+}
+function describeMissingModule(error) {
+  const message = error.message;
+  const match = typeof message === "string" ? /Cannot find (?:module|package) ['"]([^'"]+)['"]/.exec(message) : null;
+  return match ? `${match[1]} not installed` : "a required module is not installed";
+}
+async function resolveConfigExport(exported, dev) {
+  const value = typeof exported === "function" ? await exported(currentPhase(dev), { defaultConfig: {} }) : await exported;
+  return value ?? {};
+}
+function mapOverrides(config) {
+  const overrides = {};
+  if (typeof config.basePath === "string")
+    overrides.basePath = config.basePath;
+  if (typeof config.assetPrefix === "string" && config.assetPrefix.length > 0) {
+    overrides.assetPrefix = config.assetPrefix;
+  }
+  if (typeof config.trailingSlash === "boolean")
+    overrides.trailingSlash = config.trailingSlash;
+  if (typeof config.skipTrailingSlashRedirect === "boolean")
+    overrides.skipTrailingSlashRedirect = config.skipTrailingSlashRedirect;
+  if (typeof config.productionBrowserSourceMaps === "boolean")
+    overrides.productionBrowserSourceMaps = config.productionBrowserSourceMaps;
+  if (typeof config.distDir === "string" && config.distDir.length > 0 && config.output !== "export") {
+    overrides.outDir = config.distDir;
+  }
+  return overrides;
+}
+function normalizeCacheHandlerPath(config, root) {
+  const value = config.cacheHandler;
+  const cacheHandlers = config.cacheHandlers;
+  let next = config;
+  if (typeof value === "string" && isRelativePathSpecifier(value)) {
+    next = { ...next, cacheHandler: path.resolve(root, value) };
+  }
+  if (cacheHandlers && typeof cacheHandlers === "object" && !Array.isArray(cacheHandlers)) {
+    const normalized = {};
+    let changed = false;
+    for (const [key, handlerPath] of Object.entries(cacheHandlers)) {
+      if (typeof handlerPath === "string" && isRelativePathSpecifier(handlerPath)) {
+        normalized[key] = path.resolve(root, handlerPath);
+        changed = true;
+      } else {
+        normalized[key] = handlerPath;
+      }
+    }
+    if (changed)
+      next = { ...next, cacheHandlers: normalized };
+  }
+  return next;
+}
+function isRelativePathSpecifier(value) {
+  return value === "." || value === ".." || value.startsWith("./") || value.startsWith("../");
+}
+function applyEnv(config) {
+  const env = config.env;
+  if (!env || typeof env !== "object")
+    return;
+  for (const [key, value] of Object.entries(env)) {
+    if (value === undefined || value === null)
+      continue;
+    if (process.env[key] !== undefined)
+      continue;
+    process.env[key] = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+  }
+}
+function applyRuntimeConfig(config) {
+  const serverRuntimeConfig = config.serverRuntimeConfig;
+  const publicRuntimeConfig = config.publicRuntimeConfig;
+  if (!serverRuntimeConfig && !publicRuntimeConfig)
+    return;
+  setConfig({
+    ...serverRuntimeConfig && typeof serverRuntimeConfig === "object" ? { serverRuntimeConfig } : {},
+    ...publicRuntimeConfig && typeof publicRuntimeConfig === "object" ? { publicRuntimeConfig } : {}
+  });
+}
+var VALID_DEV_INDICATOR_POSITIONS = new Set([
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+]);
+var KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
+  "adapterPath",
+  "agentRules",
+  "allowedDevOrigins",
+  "assetPrefix",
+  "basePath",
+  "bundlePagesRouterDependencies",
+  "cacheComponents",
+  "cacheHandler",
+  "cacheHandlers",
+  "cacheLife",
+  "cacheMaxMemorySize",
+  "cleanDistDir",
+  "compiler",
+  "compress",
+  "configFile",
+  "configFileName",
+  "configOrigin",
+  "crossOrigin",
+  "deploymentId",
+  "devIndicators",
+  "distDir",
+  "enablePrerenderSourceMaps",
+  "env",
+  "excludeDefaultMomentLocales",
+  "expireTime",
+  "experimental",
+  "exportPathMap",
+  "generateBuildId",
+  "generateEtags",
+  "headers",
+  "htmlLimitedBots",
+  "httpAgentOptions",
+  "images",
+  "logging",
+  "modularizeImports",
+  "onDemandEntries",
+  "output",
+  "outputFileTracingExcludes",
+  "outputFileTracingIncludes",
+  "outputFileTracingRoot",
+  "pageExtensions",
+  "partialPrefetching",
+  "poweredByHeader",
+  "productionBrowserSourceMaps",
+  "publicRuntimeConfig",
+  "reactCompiler",
+  "reactMaxHeadersLength",
+  "reactProductionProfiling",
+  "reactStrictMode",
+  "resolveExtensions",
+  "redirects",
+  "rewrites",
+  "sassOptions",
+  "serverExternalPackages",
+  "serverRuntimeConfig",
+  "skipProxyUrlNormalize",
+  "skipTrailingSlashRedirect",
+  "staticPageGenerationTimeout",
+  "i18n",
+  "instrumentationClientInject",
+  "trailingSlash",
+  "skipMiddlewareUrlNormalize",
+  "transpilePackages",
+  "turbopack",
+  "typedRoutes",
+  "typescript",
+  "useFileSystemPublicRoutes",
+  "watchOptions",
+  "webpack"
+]);
+var DEPRECATED_CONFIG_OPTIONS = [
+  {
+    key: "experimental.middlewarePrefetch",
+    reason: (file) => `\`experimental.middlewarePrefetch\` is deprecated. Please use \`experimental.proxyPrefetch\` instead in ${file}.`
+  },
+  {
+    key: "experimental.middlewareClientMaxBodySize",
+    reason: (file) => `\`experimental.middlewareClientMaxBodySize\` is deprecated. Please use \`experimental.proxyClientMaxBodySize\` instead in ${file}.`
+  },
+  {
+    key: "experimental.externalMiddlewareRewritesResolve",
+    reason: (file) => `\`experimental.externalMiddlewareRewritesResolve\` is deprecated. Please use \`experimental.externalProxyRewritesResolve\` instead in ${file}.`
+  },
+  {
+    key: "skipMiddlewareUrlNormalize",
+    reason: (file) => `\`skipMiddlewareUrlNormalize\` is deprecated. Please use \`skipProxyUrlNormalize\` instead in ${file}.`
+  },
+  {
+    key: "experimental.instrumentationHook",
+    reason: (file) => `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${file}.`
+  }
+];
+var warnedConfigPaths = new Set;
+function validateConfig(config, configPath, emitWarnings) {
+  if (emitWarnings && !warnedConfigPaths.has(configPath)) {
+    warnedConfigPaths.add(configPath);
+    const configFileName = path.basename(configPath);
+    warnUnknownConfigKeys(config);
+    warnEsmExternalsFalse(config);
+    warnDeprecatedConfigOptions(config, configFileName);
+    warnWebpackCompat(config, configFileName);
+  }
+  validateDevIndicatorPosition(config);
+  const imageErrors = collectImagesConfigErrors(config, path.dirname(configPath));
+  if (imageErrors.length > 0) {
+    throw new Error(`Invalid next.config.js options detected: 
+${imageErrors.map((e) => `    ${e}`).join(`
+`)}
+See more info here: https://nextjs.org/docs/messages/invalid-next-config`);
+  }
+}
+function hasNestedKey(config, dottedKey) {
+  let current = config;
+  for (const key of dottedKey.split(".")) {
+    if (!current || typeof current !== "object")
+      return false;
+    current = current[key];
+    if (current === undefined)
+      return false;
+  }
+  return true;
+}
+function warnDeprecatedConfigOptions(config, configFileName) {
+  for (const { key, reason } of DEPRECATED_CONFIG_OPTIONS) {
+    if (hasNestedKey(config, key))
+      console.warn(reason(configFileName));
+  }
+}
+function warnUnknownConfigKeys(config) {
+  const invalid = Object.keys(config).filter((key) => !KNOWN_TOP_LEVEL_CONFIG_KEYS.has(key));
+  if (invalid.length === 0)
+    return;
+  console.warn(`Invalid next.config.js options detected: ${invalid.map((key) => `"${key}"`).join(", ")}`);
+}
+function warnWebpackCompat(config, configFileName) {
+  if (typeof config.webpack !== "function")
+    return;
+  console.warn(`\`webpack\` in ${configFileName} is not executed by pnext \u2014 esbuild is the only bundler. ` + "`transpilePackages`, `experimental.optimizePackageImports`, and `turbopack.resolveAlias` are supported natively; see https://pnext.dev/docs/compat.");
+  if (webpackReferencesSvgr(config)) {
+    console.info("pnext detected @svgr/webpack in `webpack()` and will compile `.svg` imports to inline Preact components instead (see https://pnext.dev/docs/compat).");
+  }
+}
+function warnEsmExternalsFalse(config) {
+  const experimental = config.experimental;
+  if (!experimental || typeof experimental !== "object")
+    return;
+  if (experimental.esmExternals !== false)
+    return;
+  console.warn('The "experimental.esmExternals" option has been modified. experimental.esmExternals is not recommended to be modified as it may disrupt module resolution. It should be removed from your next.config.js');
+}
+function validateDevIndicatorPosition(config) {
+  const devIndicators = config.devIndicators;
+  if (!devIndicators || typeof devIndicators !== "object")
+    return;
+  const position = devIndicators.position;
+  if (typeof position !== "string" || VALID_DEV_INDICATOR_POSITIONS.has(position))
+    return;
+  throw new Error(`Invalid "devIndicator.position" provided, expected one of top-left, top-right, bottom-left, bottom-right, received ${position}`);
+}
+async function loadNextConfig(root, options = {}) {
+  storeReleased = options.bundle !== undefined;
+  const configPath = options.bundle === undefined ? findConfigPath(root) : options.bundle;
+  if (!configPath) {
+    setNextConfig({});
+    emitSessionStartedTelemetry({});
+    return { config: {}, overrides: {} };
+  }
+  if (options.bundle && !existsSync(options.bundle)) {
+    throw new Error(`pnext: the build's compiled next.config (${options.bundle}) is missing. Run 'pnext build' again.`);
+  }
+  let exported;
+  try {
+    exported = options.bundle ? await importConfigBundle(options.bundle, options.bundle.endsWith(".cjs")) : await importConfigModule(configPath, root, {
+      dev: Boolean(options.dev),
+      serve: Boolean(options.serve)
+    });
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      console.warn(`pnext: could not load ${path.relative(root, configPath)} (${describeMissingModule(error)}); continuing with default config`);
+      setNextConfig({});
+      emitSessionStartedTelemetry({});
+      return { config: {}, overrides: {} };
+    }
+    throw error;
+  }
+  const resolved = normalizeCacheHandlerPath(await resolveConfigExport(exported, Boolean(options.dev)), root);
+  const config = options.bundle ? releasedCacheHandlers(resolved, options.handlers ?? {}) : resolved;
+  validateConfig(config, configPath, options.warnings !== false);
+  setNextConfig(config);
+  applyEnv(config);
+  applyRuntimeConfig(config);
+  emitSessionStartedTelemetry(config);
+  emitBuildFeatureUsageTelemetry(config);
+  return { config, overrides: mapOverrides(config) };
+}
+
+export { nextConfigReleased, getNextConfig, setNextConfig, emitNextConfigBundle, loadNextConfig };

package/dist/server/_chunks/index-6gex3pfa.js

@@ -0,0 +1,15 @@
+// @bun
+// src/compat/actions/unrecognized-error.ts
+class UnrecognizedActionError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = "UnrecognizedActionError";
+  }
+}
+function isUnrecognizedActionError(error) {
+  if (error instanceof UnrecognizedActionError)
+    return true;
+  return error instanceof Error && (error.name === "UnrecognizedActionError" || / was not found on the server\.?$/.test(error.message));
+}
+
+export { isUnrecognizedActionError };

package/dist/server/_chunks/index-6kp9r0d9.js

@@ -0,0 +1,11 @@
+// @bun
+// src/utils/ansi.ts
+function color(open, close) {
+  return (value) => process.stdout.isTTY && !process.env.NO_COLOR ? `${open}${value}${close}` : value;
+}
+var dim = color("\x1B[38;5;244m", "\x1B[39m");
+var bold = color("\x1B[1m", "\x1B[22m");
+var cyan = color("\x1B[36m", "\x1B[39m");
+var green = color("\x1B[32m", "\x1B[39m");
+
+export { dim, bold, cyan, green };