@granite-js/mpack 0.0.1

package/dist/vendors/metro-config/src/defaults/defaults.js

@@ -0,0 +1,66 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const defaultCreateModuleIdFactory = require("../../../metro/src/lib/createModuleIdFactory");
+exports.assetExts = [
+  // Image formats
+  "bmp",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "psd",
+  "svg",
+  "webp",
+  // Video formats
+  "m4v",
+  "mov",
+  "mp4",
+  "mpeg",
+  "mpg",
+  "webm",
+  // Audio formats
+  "aac",
+  "aiff",
+  "caf",
+  "m4a",
+  "mp3",
+  "wav",
+  // Document formats
+  "html",
+  "pdf",
+  "yaml",
+  "yml",
+  // Font formats
+  "otf",
+  "ttf",
+  // Archives (virtual files)
+  "zip"
+];
+exports.assetResolutions = ["1", "1.5", "2", "3", "4"];
+exports.sourceExts = ["js", "jsx", "json", "ts", "tsx"];
+exports.additionalExts = ["cjs", "mjs"];
+exports.moduleSystem = require.resolve("metro-runtime/src/polyfills/require.js");
+exports.platforms = ["ios", "android", "windows", "web"];
+exports.DEFAULT_METRO_MINIFIER_PATH = "metro-minify-uglify";
+exports.defaultCreateModuleIdFactory = defaultCreateModuleIdFactory;

package/dist/vendors/metro-config/src/defaults/exclusionList.d.ts

@@ -0,0 +1,3 @@
+declare function exclusionList(additionalExclusions?: (RegExp | string)[]): RegExp;
+
+export default exclusionList;

package/dist/vendors/metro-config/src/defaults/exclusionList.js

@@ -0,0 +1,17 @@
+"use strict";
+var path = require("path");
+var list = [/\/__tests__\/.*/];
+function escapeRegExp(pattern) {
+  if (Object.prototype.toString.call(pattern) === "[object RegExp]") {
+    return pattern.source.replace(/\/|\\\//g, "\\" + path.sep);
+  } else if (typeof pattern === "string") {
+    var escaped = pattern.replace(/[\-\[\]\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+    return escaped.replace(/\//g, "\\" + path.sep);
+  } else {
+    throw new Error("Unexpected exclusion pattern: " + pattern);
+  }
+}
+function exclusionList(additionalExclusions) {
+  return new RegExp("(" + (additionalExclusions || []).concat(list).map(escapeRegExp).join("|") + ")$");
+}
+module.exports = exclusionList;

package/dist/vendors/metro-config/src/defaults/index.d.ts

@@ -0,0 +1,5 @@
+declare function getDefaultConfig(rootPath: string): any;
+declare function getDefaultValues(rootPath: string): any;
+
+export default getDefaultConfig;
+export { getDefaultValues };

package/dist/vendors/metro-config/src/defaults/index.js

@@ -0,0 +1,161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const {
+  DEFAULT_METRO_MINIFIER_PATH,
+  assetExts,
+  assetResolutions,
+  additionalExts,
+  defaultCreateModuleIdFactory,
+  platforms,
+  sourceExts
+} = require("./defaults");
+const exclusionList = require("./exclusionList");
+const { FileStore } = require("metro-cache");
+const { Terminal } = require("../../../metro-core/src");
+const getMaxWorkers = require("../../../metro/src/lib/getMaxWorkers");
+const TerminalReporter = require("../../../metro/src/lib/TerminalReporter");
+const os = require("os");
+const path = require("path");
+const getDefaultValues = (projectRoot) => ({
+  resolver: {
+    assetExts,
+    assetResolutions,
+    platforms,
+    sourceExts,
+    blockList: exclusionList(),
+    dependencyExtractor: void 0,
+    disableHierarchicalLookup: false,
+    emptyModulePath: require.resolve("metro-runtime/src/modules/empty-module.js"),
+    extraNodeModules: {},
+    hasteImplModulePath: void 0,
+    nodeModulesPaths: [],
+    resolveRequest: null,
+    resolverMainFields: ["browser", "main"],
+    useWatchman: true,
+    requireCycleIgnorePatterns: [/(^|\/|\\)node_modules($|\/|\\)/]
+  },
+  serializer: {
+    polyfillModuleNames: [],
+    getRunModuleStatement: (moduleId) => `__r(${JSON.stringify(moduleId)});`,
+    getPolyfills: () => [],
+    postProcessBundleSourcemap: ({ code, map, outFileName }) => ({ code, map }),
+    getModulesRunBeforeMainModule: () => [],
+    processModuleFilter: (module2) => true,
+    createModuleIdFactory: defaultCreateModuleIdFactory,
+    experimentalSerializerHook: () => {
+    },
+    customSerializer: null
+  },
+  server: {
+    useGlobalHotkey: true,
+    port: 8080,
+    enhanceMiddleware: (middleware) => middleware,
+    rewriteRequestUrl: (url) => url,
+    runInspectorProxy: true,
+    verifyConnections: false,
+    unstable_serverRoot: null
+  },
+  symbolicator: {
+    customizeFrame: () => {
+    }
+  },
+  transformer: {
+    assetPlugins: [],
+    asyncRequireModulePath: "metro-runtime/src/modules/asyncRequire",
+    assetRegistryPath: "missing-asset-registry-path",
+    babelTransformerPath: "metro-babel-transformer",
+    dynamicDepsInPackages: "throwAtRuntime",
+    enableBabelRCLookup: true,
+    enableBabelRuntime: true,
+    experimentalImportBundleSupport: false,
+    getTransformOptions: async () => ({
+      transform: {
+        experimentalImportSupport: false,
+        inlineRequires: false,
+        unstable_disableES6Transforms: false
+      },
+      preloadedModules: false,
+      ramGroups: []
+    }),
+    globalPrefix: "",
+    hermesParser: false,
+    minifierConfig: {
+      mangle: {
+        toplevel: false
+      },
+      output: {
+        ascii_only: true,
+        quote_style: 3,
+        wrap_iife: true
+      },
+      sourceMap: {
+        includeSources: false
+      },
+      toplevel: false,
+      compress: {
+        // reduce_funcs inlines single-use functions, which cause perf regressions.
+        reduce_funcs: false
+      }
+    },
+    minifierPath: DEFAULT_METRO_MINIFIER_PATH,
+    optimizationSizeLimit: 150 * 1024,
+    // 150 KiB.
+    transformVariants: { default: {} },
+    workerPath: "metro/src/DeltaBundler/Worker",
+    publicPath: "/assets",
+    allowOptionalDependencies: false,
+    unstable_allowRequireContext: false,
+    unstable_collectDependenciesPath: "metro/src/ModuleGraph/worker/collectDependencies.js",
+    unstable_dependencyMapReservedName: null,
+    unstable_disableModuleWrapping: false,
+    unstable_disableNormalizePseudoGlobals: false,
+    unstable_compactOutput: false
+  },
+  watcher: {
+    additionalExts,
+    watchman: {
+      deferStates: ["hg.update"]
+    }
+  },
+  cacheStores: [
+    new FileStore({
+      root: path.join(os.tmpdir(), "metro-cache")
+    })
+  ],
+  cacheVersion: "1.0",
+  // We assume the default project path is two levels up from
+  // node_modules/metro/
+  projectRoot: projectRoot || path.resolve(__dirname, "../../.."),
+  stickyWorkers: true,
+  watchFolders: [],
+  transformerPath: "metro-transform-worker",
+  maxWorkers: getMaxWorkers(),
+  resetCache: false,
+  reporter: new TerminalReporter(new Terminal(process.stdout))
+});
+async function getDefaultConfig(rootPath) {
+  return getDefaultValues(rootPath);
+}
+module.exports = getDefaultConfig;
+module.exports.getDefaultValues = getDefaultValues;

package/dist/vendors/metro-config/src/defaults/validConfig.js

@@ -0,0 +1,28 @@
+"use strict";
+module.exports = async () => {
+  const defaultConfig = await require("./index")("/path/to/project");
+  const validConfig = {
+    ...defaultConfig,
+    resolver: {
+      ...defaultConfig.resolver,
+      resolveRequest: function CustomResolver() {
+      },
+      hasteImplModulePath: "./path"
+    },
+    server: {
+      ...defaultConfig.server,
+      unstable_serverRoot: ""
+    },
+    transformer: {
+      ...defaultConfig.transformer,
+      getTransformOptions: function getTransformOptions() {
+      }
+    },
+    serializer: {
+      ...defaultConfig.serializer,
+      customSerializer: function customSerializer() {
+      }
+    }
+  };
+  return validConfig;
+};

package/dist/vendors/metro-config/src/index.js

@@ -0,0 +1,9 @@
+"use strict";
+const getDefaultConfig = require("./defaults");
+const { loadConfig, mergeConfig, resolveConfig } = require("./loadConfig");
+module.exports = {
+  loadConfig,
+  resolveConfig,
+  mergeConfig,
+  getDefaultConfig
+};

package/dist/vendors/metro-config/src/loadConfig.d.ts

@@ -0,0 +1,4 @@
+declare function loadConfig(argv: any, defaultConfigOverrides: any): Promise<any>;
+declare function mergeConfig(defaultConfig: any, ...configs: any[]): any;
+
+export { loadConfig, mergeConfig };

package/dist/vendors/metro-config/src/loadConfig.js

@@ -0,0 +1,188 @@
+"use strict";
+const getDefaultConfig = require("./defaults");
+const validConfig = require("./defaults/validConfig");
+const { cosmiconfig, defaultLoaders } = require("cosmiconfig");
+const fs = require("fs");
+const { validate } = require("jest-validate");
+const MetroCache = require("metro-cache");
+const path = require("path");
+const { dirname, join } = require("path");
+function overrideArgument(arg) {
+  if (arg == null) {
+    return arg;
+  }
+  if (Array.isArray(arg)) {
+    return arg[arg.length - 1];
+  }
+  return arg;
+}
+const explorer = cosmiconfig("metro", {
+  searchPlaces: ["metro.config.js", "metro.config.json", "package.json"],
+  loaders: {
+    // MARK: - GRANITE
+    ...defaultLoaders,
+    ".es6": defaultLoaders[".js"],
+    noExt: cosmiconfig.loadYaml
+  }
+});
+const isFile = (filePath) => fs.existsSync(filePath) && !fs.lstatSync(filePath).isDirectory();
+const resolve = (filePath) => {
+  try {
+    return require.resolve(filePath);
+  } catch (error) {
+    if (path.isAbsolute(filePath) || error.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  const possiblePath = path.resolve(process.cwd(), filePath);
+  return isFile(possiblePath) ? possiblePath : filePath;
+};
+async function resolveConfig(filePath, cwd) {
+  if (filePath) {
+    return explorer.load(resolve(filePath));
+  }
+  const result = await explorer.search(cwd);
+  if (result == null) {
+    return {
+      isEmpty: true,
+      filepath: join(cwd || process.cwd(), "metro.config.stub.js"),
+      config: {}
+    };
+  }
+  return result;
+}
+function mergeConfig(defaultConfig, ...configs) {
+  return configs.reduce(
+    (totalConfig, nextConfig) => ({
+      ...totalConfig,
+      ...nextConfig,
+      cacheStores: nextConfig.cacheStores != null ? typeof nextConfig.cacheStores === "function" ? nextConfig.cacheStores(MetroCache) : nextConfig.cacheStores : totalConfig.cacheStores,
+      resolver: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.resolver,
+        ...nextConfig.resolver || {},
+        dependencyExtractor: nextConfig.resolver && nextConfig.resolver.dependencyExtractor != null ? resolve(nextConfig.resolver.dependencyExtractor) : totalConfig.resolver.dependencyExtractor,
+        hasteImplModulePath: nextConfig.resolver && nextConfig.resolver.hasteImplModulePath != null ? resolve(nextConfig.resolver.hasteImplModulePath) : totalConfig.resolver.hasteImplModulePath
+      },
+      serializer: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.serializer,
+        ...nextConfig.serializer || {}
+      },
+      transformer: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.transformer,
+        ...nextConfig.transformer || {},
+        babelTransformerPath: nextConfig.transformer && nextConfig.transformer.babelTransformerPath != null ? resolve(nextConfig.transformer.babelTransformerPath) : totalConfig.transformer.babelTransformerPath
+      },
+      server: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.server,
+        ...nextConfig.server || {}
+      },
+      symbolicator: {
+        /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+         * an error found when Flow v0.111 was deployed. To see the error,
+         * delete this comment and run Flow. */
+        ...totalConfig.symbolicator,
+        ...nextConfig.symbolicator || {}
+      },
+      watcher: {
+        ...totalConfig.watcher,
+        ...nextConfig.watcher,
+        watchman: {
+          ...totalConfig.watcher?.watchman,
+          ...nextConfig.watcher?.watchman
+        }
+      }
+    }),
+    defaultConfig
+  );
+}
+async function loadMetroConfigFromDisk(path2, cwd, defaultConfigOverrides) {
+  const resolvedConfigResults = await resolveConfig(path2, cwd);
+  const { config: configModule, filepath } = resolvedConfigResults;
+  const rootPath = dirname(filepath);
+  const defaults = await getDefaultConfig(rootPath);
+  const defaultConfig = mergeConfig(defaults, defaultConfigOverrides);
+  if (typeof configModule === "function") {
+    const resultedConfig = await configModule(defaultConfig);
+    return mergeConfig(defaultConfig, resultedConfig);
+  }
+  return mergeConfig(defaultConfig, configModule);
+}
+function overrideConfigWithArguments(config, argv) {
+  const output = {
+    resolver: {},
+    serializer: {},
+    server: {},
+    transformer: {}
+  };
+  if (argv.port != null) {
+    output.server.port = Number(argv.port);
+  }
+  if (argv.runInspectorProxy != null) {
+    output.server.runInspectorProxy = Boolean(argv.runInspectorProxy);
+  }
+  if (argv.projectRoot != null) {
+    output.projectRoot = argv.projectRoot;
+  }
+  if (argv.watchFolders != null) {
+    output.watchFolders = argv.watchFolders;
+  }
+  if (argv.assetExts != null) {
+    output.resolver.assetExts = argv.assetExts;
+  }
+  if (argv.sourceExts != null) {
+    output.resolver.sourceExts = argv.sourceExts;
+  }
+  if (argv.platforms != null) {
+    output.resolver.platforms = argv.platforms;
+  }
+  if (argv["max-workers"] != null || argv.maxWorkers != null) {
+    output.maxWorkers = Number(argv["max-workers"] || argv.maxWorkers);
+  }
+  if (argv.transformer != null) {
+    output.transformer.babelTransformerPath = argv.transformer;
+  }
+  if (argv["reset-cache"] != null) {
+    output.resetCache = argv["reset-cache"];
+  }
+  if (argv.resetCache != null) {
+    output.resetCache = argv.resetCache;
+  }
+  if (argv.verbose === false) {
+    output.reporter = { update: () => {
+    } };
+  }
+  return mergeConfig(config, output);
+}
+async function loadConfig(argv = {}, defaultConfigOverrides = {}) {
+  argv.config = overrideArgument(argv.config);
+  const configuration = await loadMetroConfigFromDisk(argv.config, argv.cwd, defaultConfigOverrides);
+  validate(configuration, {
+    exampleConfig: await validConfig(),
+    recursiveBlacklist: ["reporter", "resolver", "transformer"],
+    deprecatedConfig: {
+      blacklistRE: () => `Warning: Metro config option \`blacklistRE\` is deprecated.
+         Please use \`blockList\` instead.`
+    }
+  });
+  const configWithArgs = overrideConfigWithArguments(configuration, argv);
+  const overriddenConfig = {};
+  overriddenConfig.watchFolders = [configWithArgs.projectRoot, ...configWithArgs.watchFolders];
+  return mergeConfig(configWithArgs, overriddenConfig);
+}
+module.exports = {
+  loadConfig,
+  resolveConfig,
+  mergeConfig
+};

package/dist/vendors/metro-core/src/Logger.js

@@ -0,0 +1,62 @@
+"use strict";
+const VERSION = "0.0.0";
+const { EventEmitter } = require("events");
+const os = require("os");
+const path = require("path");
+const log_session = `${os.hostname()}-${Date.now()}`;
+const eventEmitter = new EventEmitter();
+function on(event, handler) {
+  eventEmitter.on(event, handler);
+}
+function createEntry(data) {
+  const logEntry = typeof data === "string" ? { log_entry_label: data } : data;
+  const entryPoint = logEntry.entry_point;
+  if (entryPoint) {
+    logEntry.entry_point = path.relative(process.cwd(), entryPoint);
+  }
+  return {
+    ...logEntry,
+    log_session,
+    metro_bundler_version: VERSION
+  };
+}
+function createActionStartEntry(data) {
+  const logEntry = typeof data === "string" ? { action_name: data } : data;
+  const { action_name } = logEntry;
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: "start",
+    log_entry_label: action_name,
+    start_timestamp: process.hrtime()
+  });
+}
+function createActionEndEntry(logEntry) {
+  const { action_name, action_phase, start_timestamp } = logEntry;
+  if (action_phase !== "start" || !Array.isArray(start_timestamp)) {
+    throw new Error("Action has not started or has already ended");
+  }
+  const timeDelta = process.hrtime(start_timestamp);
+  const duration_ms = Math.round((timeDelta[0] * 1e9 + timeDelta[1]) / 1e6);
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: "end",
+    duration_ms,
+    /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.111 was deployed. To see the error, delete this
+     * comment and run Flow. */
+    log_entry_label: action_name
+  });
+}
+function log(logEntry) {
+  eventEmitter.emit("log", logEntry);
+  return logEntry;
+}
+module.exports = {
+  on,
+  createEntry,
+  createActionStartEntry,
+  createActionEndEntry,
+  log
+};

package/dist/vendors/metro-core/src/Terminal.d.ts

@@ -0,0 +1,30 @@
+import type * as net from 'net';
+import type * as stream from 'stream';
+
+type UnderlyingStream = net.Socket | stream.Writable;
+
+declare class Terminal {
+  constructor(stream: UnderlyingStream);
+  /**
+   * Shows some text that is meant to be overriden later. Return the previous
+   * status that was shown and is no more. Calling `status()` with no argument
+   * removes the status altogether. The status is never shown in a
+   * non-interactive terminal: for example, if the output is redirected to a
+   * file, then we don't care too much about having a progress bar.
+   */
+  status(format: string, ...args: unknown[]): string;
+  /**
+   * Similar to `console.log`, except it moves the status/progress text out of
+   * the way correctly. In non-interactive terminals this is the same as
+   * `console.log`.
+   */
+  log(format: string, ...args: unknown[]): void;
+  /**
+   * Log the current status and start from scratch. This is useful if the last
+   * status was the last one of a series of updates.
+   */
+  persistStatus(): void;
+  flush(): void;
+}
+
+export default Terminal;

package/dist/vendors/metro-core/src/Terminal.js

@@ -0,0 +1,100 @@
+"use strict";
+const throttle = require("lodash.throttle");
+const readline = require("readline");
+const tty = require("tty");
+const util = require("util");
+function clearStringBackwards(stream, str) {
+  readline.moveCursor(stream, -stream.columns, 0);
+  readline.clearLine(stream, 0);
+  let lineCount = (str.match(/\n/g) || []).length;
+  while (lineCount > 0) {
+    readline.moveCursor(stream, 0, -1);
+    readline.clearLine(stream, 0);
+    --lineCount;
+  }
+}
+function chunkString(str, size) {
+  const ANSI_COLOR = "\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?m";
+  const SKIP_ANSI = `(?:${ANSI_COLOR})*`;
+  return str.match(new RegExp(`(?:${SKIP_ANSI}.){1,${size}}`, "g")) || [];
+}
+function getTTYStream(stream) {
+  if (stream instanceof tty.WriteStream && stream.isTTY && stream.columns >= 1) {
+    return stream;
+  }
+  return null;
+}
+class Terminal {
+  _logLines;
+  _nextStatusStr;
+  _scheduleUpdate;
+  _statusStr;
+  _stream;
+  constructor(stream) {
+    this._logLines = [];
+    this._nextStatusStr = "";
+    this._scheduleUpdate = throttle(this._update, 33);
+    this._statusStr = "";
+    this._stream = stream;
+  }
+  /**
+   * Clear and write the new status, logging in bulk in-between. Doing this in a
+   * throttled way (in a different tick than the calls to `log()` and
+   * `status()`) prevents us from repeatedly rewriting the status in case
+   * `terminal.log()` is called several times.
+   */
+  _update() {
+    const { _statusStr, _stream } = this;
+    const ttyStream = getTTYStream(_stream);
+    if (_statusStr === this._nextStatusStr && this._logLines.length === 0) {
+      return;
+    }
+    if (ttyStream != null) {
+      clearStringBackwards(ttyStream, _statusStr);
+    }
+    this._logLines.forEach((line) => {
+      _stream.write(line);
+      _stream.write("\n");
+    });
+    this._logLines = [];
+    if (ttyStream != null) {
+      this._nextStatusStr = chunkString(this._nextStatusStr, ttyStream.columns).join("\n");
+      _stream.write(this._nextStatusStr);
+    }
+    this._statusStr = this._nextStatusStr;
+  }
+  /**
+   * Shows some text that is meant to be overriden later. Return the previous
+   * status that was shown and is no more. Calling `status()` with no argument
+   * removes the status altogether. The status is never shown in a
+   * non-interactive terminal: for example, if the output is redirected to a
+   * file, then we don't care too much about having a progress bar.
+   */
+  status(format, ...args) {
+    const { _nextStatusStr } = this;
+    this._nextStatusStr = util.format(format, ...args);
+    this._scheduleUpdate();
+    return _nextStatusStr;
+  }
+  /**
+   * Similar to `console.log`, except it moves the status/progress text out of
+   * the way correctly. In non-interactive terminals this is the same as
+   * `console.log`.
+   */
+  log(format, ...args) {
+    this._logLines.push(util.format(format, ...args));
+    this._scheduleUpdate();
+  }
+  /**
+   * Log the current status and start from scratch. This is useful if the last
+   * status was the last one of a series of updates.
+   */
+  persistStatus() {
+    this.log(this._nextStatusStr);
+    this._nextStatusStr = "";
+  }
+  flush() {
+    this._scheduleUpdate.flush();
+  }
+}
+module.exports = Terminal;