cleaned up viewers

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/esm.mjs

@@ -0,0 +1,16 @@
+import commander from './index.js';
+
+// wrapper to provide named exports for ESM.
+export const {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError, // deprecated old name
+  Command,
+  Argument,
+  Option,
+  Help
+} = commander;

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/index.js

@@ -0,0 +1,27 @@
+const { Argument } = require('./lib/argument.js');
+const { Command } = require('./lib/command.js');
+const { CommanderError, InvalidArgumentError } = require('./lib/error.js');
+const { Help } = require('./lib/help.js');
+const { Option } = require('./lib/option.js');
+
+// @ts-check
+
+/**
+ * Expose the root command.
+ */
+
+exports = module.exports = new Command();
+exports.program = exports; // More explicit access to global command.
+// Implicit export of createArgument, createCommand, and createOption.
+
+/**
+ * Expose classes
+ */
+
+exports.Argument = Argument;
+exports.Command = Command;
+exports.CommanderError = CommanderError;
+exports.Help = Help;
+exports.InvalidArgumentError = InvalidArgumentError;
+exports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated
+exports.Option = Option;

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/package-support.json

@@ -0,0 +1,16 @@
+{
+  "versions": [
+    {
+      "version": "*",
+      "target": {
+        "node": "supported"
+      },
+      "response": {
+        "type": "time-permitting"
+      },
+      "backing": {
+        "npm-funding": true
+      }
+    }
+  ]
+}

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "commander",
+  "version": "10.0.1",
+  "description": "the complete solution for node.js command-line programs",
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser",
+    "cli",
+    "argument",
+    "args",
+    "argv"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "lint": "npm run lint:javascript && npm run lint:typescript",
+    "lint:javascript": "eslint index.js esm.mjs \"lib/*.js\" \"tests/**/*.js\"",
+    "lint:typescript": "eslint typings/*.ts tests/*.ts",
+    "test": "jest && npm run test-typings",
+    "test-esm": "node ./tests/esm-imports-test.mjs",
+    "test-typings": "tsd",
+    "typescript-checkJS": "tsc --allowJS --checkJS index.js lib/*.js --noEmit",
+    "test-all": "npm run test && npm run lint && npm run typescript-checkJS && npm run test-esm"
+  },
+  "files": [
+    "index.js",
+    "lib/*.js",
+    "esm.mjs",
+    "typings/index.d.ts",
+    "package-support.json"
+  ],
+  "type": "commonjs",
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "types": "./typings/index.d.ts",
+      "require": "./index.js",
+      "import": "./esm.mjs"
+    },
+    "./esm.mjs": "./esm.mjs"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.4",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.47.1",
+    "@typescript-eslint/parser": "^5.47.1",
+    "eslint": "^8.30.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-config-standard-with-typescript": "^24.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jest": "^27.1.7",
+    "eslint-plugin-n": "^15.6.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "tsd": "^0.25.0",
+    "typescript": "^4.9.4"
+  },
+  "types": "typings/index.d.ts",
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverage": true,
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ]
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "support": true
+}

build_vtk_bundle/node_modules/webpack-cli/node_modules/commander/typings/index.d.ts

@@ -0,0 +1,889 @@
+// Type definitions for commander
+// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+
+// Using method rather than property for method-signature-style, to document method overloads separately. Allow either.
+/* eslint-disable @typescript-eslint/method-signature-style */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export class CommanderError extends Error {
+  code: string;
+  exitCode: number;
+  message: string;
+  nestedError?: string;
+
+  /**
+   * Constructs the CommanderError class
+   * @param exitCode - suggested exit code which could be used with process.exit
+   * @param code - an id string representing the error
+   * @param message - human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode: number, code: string, message: string);
+}
+
+export class InvalidArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidArgumentError class
+   * @param message - explanation of why argument is invalid
+   * @constructor
+   */
+  constructor(message: string);
+}
+export { InvalidArgumentError as InvalidOptionArgumentError }; // deprecated old name
+
+export interface ErrorOptions { // optional parameter for error()
+  /** an id string representing the error */
+  code?: string;
+  /** suggested exit code which could be used with process.exit */
+  exitCode?: number;
+}
+
+export class Argument {
+  description: string;
+  required: boolean;
+  variadic: boolean;
+
+  /**
+   * Initialize a new command argument with the given name and description.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   */
+  constructor(arg: string, description?: string);
+
+  /**
+   * Return argument name.
+   */
+  name(): string;
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+
+  /**
+   * Only allow argument value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+
+  /**
+   * Make argument required.
+   */
+  argRequired(): this;
+
+  /**
+   * Make argument optional.
+   */
+  argOptional(): this;
+}
+
+export class Option {
+  flags: string;
+  description: string;
+
+  required: boolean; // A value must be supplied when the option is specified.
+  optional: boolean; // A value is optional when the option is specified.
+  variadic: boolean;
+  mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
+  short?: string;
+  long?: string;
+  negate: boolean;
+  defaultValue?: any;
+  defaultValueDescription?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
+  hidden: boolean;
+  argChoices?: string[];
+
+  constructor(flags: string, description?: string);
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * ```ts
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   * ```
+   */
+  preset(arg: unknown): this;
+
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * ```ts
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   * ```
+   */
+  conflicts(names: string | string[]): this;
+
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   */
+  implies(optionValues: OptionValues): this;
+
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variables is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   */
+  env(name: string): this;
+
+  /**
+   * Calculate the full description, including defaultValue etc.
+   */
+  fullDescription(): string;
+
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   */
+  makeOptionMandatory(mandatory?: boolean): this;
+
+  /**
+   * Hide option in help.
+   */
+  hideHelp(hide?: boolean): this;
+
+  /**
+   * Only allow option value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+
+  /**
+   * Return option name.
+   */
+  name(): string;
+
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as a object attribute key.
+   */
+  attributeName(): string;
+
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   */
+  isBoolean(): boolean;
+}
+
+export class Help {
+  /** output helpWidth, long lines are wrapped to fit */
+  helpWidth?: number;
+  sortSubcommands: boolean;
+  sortOptions: boolean;
+  showGlobalOptions: boolean;
+
+  constructor();
+
+  /** Get the command term to show in the list of subcommands. */
+  subcommandTerm(cmd: Command): string;
+  /** Get the command summary to show in the list of subcommands. */
+  subcommandDescription(cmd: Command): string;
+  /** Get the option term to show in the list of options. */
+  optionTerm(option: Option): string;
+  /** Get the option description to show in the list of options. */
+  optionDescription(option: Option): string;
+  /** Get the argument term to show in the list of arguments. */
+  argumentTerm(argument: Argument): string;
+  /** Get the argument description to show in the list of arguments. */
+  argumentDescription(argument: Argument): string;
+
+  /** Get the command usage to be displayed at the top of the built-in help. */
+  commandUsage(cmd: Command): string;
+  /** Get the description for the command. */
+  commandDescription(cmd: Command): string;
+
+  /** Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. */
+  visibleCommands(cmd: Command): Command[];
+  /** Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. */
+  visibleOptions(cmd: Command): Option[];
+  /** Get an array of the visible global options. (Not including help.) */
+  visibleGlobalOptions(cmd: Command): Option[];
+  /** Get an array of the arguments which have descriptions. */
+  visibleArguments(cmd: Command): Argument[];
+
+  /** Get the longest command term length. */
+  longestSubcommandTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest option term length. */
+  longestOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest global option term length. */
+  longestGlobalOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest argument term length. */
+  longestArgumentTermLength(cmd: Command, helper: Help): number;
+  /** Calculate the pad width from the maximum term length. */
+  padWidth(cmd: Command, helper: Help): number;
+
+  /**
+   * Wrap the given string to width characters per line, with lines after the first indented.
+   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   */
+  wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
+
+  /** Generate the built-in help text. */
+  formatHelp(cmd: Command, helper: Help): string;
+}
+export type HelpConfiguration = Partial<Help>;
+
+export interface ParseOptions {
+  from: 'node' | 'electron' | 'user';
+}
+export interface HelpContext { // optional parameter for .help() and .outputHelp()
+  error: boolean;
+}
+export interface AddHelpTextContext { // passed to text function used with .addHelpText()
+  error: boolean;
+  command: Command;
+}
+export interface OutputConfiguration {
+  writeOut?(str: string): void;
+  writeErr?(str: string): void;
+  getOutHelpWidth?(): number;
+  getErrHelpWidth?(): number;
+  outputError?(str: string, write: (str: string) => void): void;
+
+}
+
+export type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
+export type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';
+export type OptionValueSource = 'default' | 'config' | 'env' | 'cli' | 'implied';
+
+export type OptionValues = Record<string, any>;
+
+export class Command {
+  args: string[];
+  processedArgs: any[];
+  readonly commands: readonly Command[];
+  readonly options: readonly Option[];
+  parent: Command | null;
+
+  constructor(name?: string);
+
+  /**
+   * Set the program version to `str`.
+   *
+   * This method auto-registers the "-V, --version" flag
+   * which will print the version number when passed.
+   *
+   * You can optionally supply the  flags and description to override the defaults.
+   */
+  version(str: string, flags?: string, description?: string): this;
+
+  /**
+   * Define a command, implemented using an action handler.
+   *
+   * @remarks
+   * The command description is supplied using `.description`, not as a parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   * program
+   *   .command('clone <source> [destination]')
+   *   .description('clone a repository into a newly created directory')
+   *   .action((source, destination) => {
+   *     console.log('clone command called');
+   *   });
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param opts - configuration options
+   * @returns new command
+   */
+  command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
+  /**
+   * Define a command, implemented in a separate executable file.
+   *
+   * @remarks
+   * The command description is supplied as the second parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   *  program
+   *    .command('start <service>', 'start named service')
+   *    .command('stop [service]', 'stop named service, or all if no name supplied');
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param description - description of executable command
+   * @param opts - configuration options
+   * @returns `this` command for chaining
+   */
+  command(nameAndArgs: string, description: string, opts?: ExecutableCommandOptions): this;
+
+  /**
+   * Factory routine to create a new unattached command.
+   *
+   * See .command() for creating an attached subcommand, which uses this routine to
+   * create the command. You can override createCommand to customise subcommands.
+   */
+  createCommand(name?: string): Command;
+
+  /**
+   * Add a prepared subcommand.
+   *
+   * See .command() for creating an attached subcommand which inherits settings from its parent.
+   *
+   * @returns `this` command for chaining
+   */
+  addCommand(cmd: Command, opts?: CommandOptions): this;
+
+  /**
+   * Factory routine to create a new unattached argument.
+   *
+   * See .argument() for creating an attached argument, which uses this routine to
+   * create the argument. You can override createArgument to return a custom argument.
+   */
+  createArgument(name: string, description?: string): Argument;
+
+  /**
+   * Define argument syntax for command.
+   *
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @example
+   * ```
+   * program.argument('<input-file>');
+   * program.argument('[output-file]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  argument<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  argument(name: string, description?: string, defaultValue?: unknown): this;
+
+  /**
+   * Define argument syntax for command, adding a prepared argument.
+   *
+   * @returns `this` command for chaining
+   */
+  addArgument(arg: Argument): this;
+
+  /**
+   * Define argument syntax for command, adding multiple at once (without descriptions).
+   *
+   * See also .argument().
+   *
+   * @example
+   * ```
+   * program.arguments('<cmd> [env]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  arguments(names: string): this;
+
+  /**
+   * Override default decision whether to add implicit help command.
+   *
+   * @example
+   * ```
+   * addHelpCommand() // force on
+   * addHelpCommand(false); // force off
+   * addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  addHelpCommand(enableOrNameAndArgs?: string | boolean, description?: string): this;
+
+  /**
+   * Add hook for life cycle event.
+   */
+  hook(event: HookEvent, listener: (thisCommand: Command, actionCommand: Command) => void | Promise<void>): this;
+
+  /**
+   * Register callback to use as replacement for calling process.exit.
+   */
+  exitOverride(callback?: (err: CommanderError) => never | void): this;
+
+  /**
+   * Display error message and exit (or call exitOverride).
+   */
+  error(message: string, errorOptions?: ErrorOptions): never;
+
+  /**
+   * You can customise the help with a subclass of Help by overriding createHelp,
+   * or by overriding Help properties using configureHelp().
+   */
+  createHelp(): Help;
+
+  /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   */
+  configureHelp(configuration: HelpConfiguration): this;
+  /** Get configuration */
+  configureHelp(): HelpConfiguration;
+
+  /**
+   * The default output goes to stdout and stderr. You can customise this for special
+   * applications. You can also customise the display of errors by overriding outputError.
+   *
+   * The configuration properties are all functions:
+   * ```
+   * // functions to change where being written, stdout and stderr
+   * writeOut(str)
+   * writeErr(str)
+   * // matching functions to specify width for wrapping help
+   * getOutHelpWidth()
+   * getErrHelpWidth()
+   * // functions based on what is being written out
+   * outputError(str, write) // used for displaying errors, and not used for displaying help
+   * ```
+   */
+  configureOutput(configuration: OutputConfiguration): this;
+  /** Get configuration */
+  configureOutput(): OutputConfiguration;
+
+  /**
+   * Copy settings that are useful to have in common across root command and subcommands.
+   *
+   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
+   */
+  copyInheritedSettings(sourceCommand: Command): this;
+
+  /**
+   * Display the help or a custom message after an error occurs.
+   */
+  showHelpAfterError(displayHelp?: boolean | string): this;
+
+  /**
+   * Display suggestion of similar commands for unknown commands, or options for unknown options.
+   */
+  showSuggestionAfterError(displaySuggestion?: boolean): this;
+
+  /**
+   * Register callback `fn` for the command.
+   *
+   * @example
+   * ```
+   * program
+   *   .command('serve')
+   *   .description('start service')
+   *   .action(function() {
+   *     // do work here
+   *   });
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  action(fn: (...args: any[]) => void | Promise<void>): this;
+
+  /**
+   * Define option with `flags`, `description` and optional
+   * coercion `fn`.
+   *
+   * The `flags` string contains the short and/or long flags,
+   * separated by comma, a pipe or space. The following are all valid
+   * all will output this way when `--help` is used.
+   *
+   *     "-p, --pepper"
+   *     "-p|--pepper"
+   *     "-p --pepper"
+   *
+   * @example
+   * ```
+   * // simple boolean defaulting to false
+   *  program.option('-p, --pepper', 'add pepper');
+   *
+   *  --pepper
+   *  program.pepper
+   *  // => Boolean
+   *
+   *  // simple boolean defaulting to true
+   *  program.option('-C, --no-cheese', 'remove cheese');
+   *
+   *  program.cheese
+   *  // => true
+   *
+   *  --no-cheese
+   *  program.cheese
+   *  // => false
+   *
+   *  // required argument
+   *  program.option('-C, --chdir <path>', 'change the working directory');
+   *
+   *  --chdir /tmp
+   *  program.chdir
+   *  // => "/tmp"
+   *
+   *  // optional argument
+   *  program.option('-c, --cheese [type]', 'add cheese [marble]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  option(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  option<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+
+  /**
+   * Define a required option, which must have a value after parsing. This usually means
+   * the option must be specified on the command line. (Otherwise the same as .option().)
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+   */
+  requiredOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  requiredOption<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+
+  /**
+   * Factory routine to create a new unattached option.
+   *
+   * See .option() for creating an attached option, which uses this routine to
+   * create the option. You can override createOption to return a custom option.
+   */
+
+  createOption(flags: string, description?: string): Option;
+
+  /**
+   * Add a prepared Option.
+   *
+   * See .option() and .requiredOption() for creating and attaching an option in a single call.
+   */
+  addOption(option: Option): this;
+
+  /**
+   * Whether to store option values as properties on command object,
+   * or store separately (specify false). In both cases the option values can be accessed using .opts().
+   *
+   * @returns `this` command for chaining
+   */
+  storeOptionsAsProperties<T extends OptionValues>(): this & T;
+  storeOptionsAsProperties<T extends OptionValues>(storeAsProperties: true): this & T;
+  storeOptionsAsProperties(storeAsProperties?: boolean): this;
+
+  /**
+   * Retrieve option value.
+   */
+  getOptionValue(key: string): any;
+
+  /**
+   * Store option value.
+   */
+  setOptionValue(key: string, value: unknown): this;
+
+  /**
+   * Store option value and where the value came from.
+   */
+  setOptionValueWithSource(key: string, value: unknown, source: OptionValueSource): this;
+
+  /**
+   * Get source of option value.
+   */
+  getOptionValueSource(key: string): OptionValueSource | undefined;
+
+  /**
+    * Get source of option value. See also .optsWithGlobals().
+   */
+  getOptionValueSourceWithGlobals(key: string): OptionValueSource | undefined;
+
+  /**
+   * Alter parsing of short flags with optional values.
+   *
+   * @example
+   * ```
+   * // for `.option('-f,--flag [value]'):
+   * .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
+   * .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  combineFlagAndOptionalValue(combine?: boolean): this;
+
+  /**
+   * Allow unknown options on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  allowUnknownOption(allowUnknown?: boolean): this;
+
+  /**
+   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+   *
+   * @returns `this` command for chaining
+   */
+  allowExcessArguments(allowExcess?: boolean): this;
+
+  /**
+   * Enable positional options. Positional means global options are specified before subcommands which lets
+   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+   *
+   * The default behaviour is non-positional and global options may appear anywhere on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  enablePositionalOptions(positional?: boolean): this;
+
+  /**
+   * Pass through options that come after command-arguments rather than treat them as command-options,
+   * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+   * positional options to have been enabled on the program (parent commands).
+   *
+   * The default behaviour is non-positional and options may appear before or after command-arguments.
+   *
+   * @returns `this` command for chaining
+   */
+  passThroughOptions(passThrough?: boolean): this;
+
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * @example
+   * ```
+   * program.parse(process.argv);
+   * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  parse(argv?: readonly string[], options?: ParseOptions): this;
+
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * @example
+   * ```
+   * program.parseAsync(process.argv);
+   * program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns Promise
+   */
+  parseAsync(argv?: readonly string[], options?: ParseOptions): Promise<this>;
+
+  /**
+   * Parse options from `argv` removing known options,
+   * and return argv split into operands and unknown arguments.
+   *
+   *     argv => operands, unknown
+   *     --known kkk op => [op], []
+   *     op --known kkk => [op], []
+   *     sub --unknown uuu op => [sub], [--unknown uuu op]
+   *     sub -- --unknown uuu op => [sub --unknown uuu op], []
+   */
+  parseOptions(argv: string[]): ParseOptionsResult;
+
+  /**
+   * Return an object containing local option values as key-value pairs
+   */
+  opts<T extends OptionValues>(): T;
+
+  /**
+   * Return an object containing merged local and global option values as key-value pairs.
+   */
+  optsWithGlobals<T extends OptionValues>(): T;
+
+  /**
+   * Set the description.
+   *
+   * @returns `this` command for chaining
+   */
+
+  description(str: string): this;
+  /** @deprecated since v8, instead use .argument to add command argument with description */
+  description(str: string, argsDescription: Record<string, string>): this;
+  /**
+   * Get the description.
+   */
+  description(): string;
+
+  /**
+   * Set the summary. Used when listed as subcommand of parent.
+   *
+   * @returns `this` command for chaining
+   */
+
+  summary(str: string): this;
+  /**
+   * Get the summary.
+   */
+  summary(): string;
+
+  /**
+   * Set an alias for the command.
+   *
+   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  alias(alias: string): this;
+  /**
+   * Get alias for the command.
+   */
+  alias(): string;
+
+  /**
+   * Set aliases for the command.
+   *
+   * Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  aliases(aliases: readonly string[]): this;
+  /**
+   * Get aliases for the command.
+   */
+  aliases(): string[];
+
+  /**
+   * Set the command usage.
+   *
+   * @returns `this` command for chaining
+   */
+  usage(str: string): this;
+  /**
+   * Get the command usage.
+   */
+  usage(): string;
+
+  /**
+   * Set the name of the command.
+   *
+   * @returns `this` command for chaining
+   */
+  name(str: string): this;
+  /**
+   * Get the name of the command.
+   */
+  name(): string;
+
+  /**
+   * Set the name of the command from script filename, such as process.argv[1],
+   * or require.main.filename, or __filename.
+   *
+   * (Used internally and public although not documented in README.)
+   *
+   * @example
+   * ```ts
+   * program.nameFromFilename(require.main.filename);
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  nameFromFilename(filename: string): this;
+
+  /**
+   * Set the directory for searching for executable subcommands of this command.
+   *
+   * @example
+   * ```ts
+   * program.executableDir(__dirname);
+   * // or
+   * program.executableDir('subcommands');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  executableDir(path: string): this;
+  /**
+   * Get the executable search directory.
+   */
+  executableDir(): string;
+
+  /**
+   * Output help information for this command.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   */
+  outputHelp(context?: HelpContext): void;
+  /** @deprecated since v7 */
+  outputHelp(cb?: (str: string) => string): void;
+
+  /**
+   * Return command help documentation.
+   */
+  helpInformation(context?: HelpContext): string;
+
+  /**
+   * You can pass in flags and a description to override the help
+   * flags and help description for your command. Pass in false
+   * to disable the built-in help option.
+   */
+  helpOption(flags?: string | boolean, description?: string): this;
+
+  /**
+   * Output help information and exit.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   */
+  help(context?: HelpContext): never;
+  /** @deprecated since v7 */
+  help(cb?: (str: string) => string): never;
+
+  /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   */
+  addHelpText(position: AddHelpTextPosition, text: string): this;
+  addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string): this;
+
+  /**
+   * Add a listener (callback) for when events occur. (Implemented using EventEmitter.)
+   */
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export interface CommandOptions {
+  hidden?: boolean;
+  isDefault?: boolean;
+  /** @deprecated since v7, replaced by hidden */
+  noHelp?: boolean;
+}
+export interface ExecutableCommandOptions extends CommandOptions {
+  executableFile?: string;
+}
+
+export interface ParseOptionsResult {
+  operands: string[];
+  unknown: string[];
+}
+
+export function createCommand(name?: string): Command;
+export function createOption(flags: string, description?: string): Option;
+export function createArgument(name: string, description?: string): Argument;
+
+export const program: Command;

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018, 2022 Tyler Kellen <tyler@sleekcode.net>, Blaine Bublitz <blaine.bublitz@gmail.com>, and Eric Schoffstall <yo@contra.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/README.md

@@ -0,0 +1,244 @@
+<p align="center">
+  <a href="http://gulpjs.com">
+    <img height="257" width="114" src="https://raw.githubusercontent.com/gulpjs/artwork/master/gulp-2x.png">
+  </a>
+</p>
+
+# interpret
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][ci-image]][ci-url] [![Coveralls Status][coveralls-image]][coveralls-url]
+
+A dictionary of file extensions and associated module loaders.
+
+## What is it
+
+This is used by [Liftoff] to automatically require dependencies for configuration files, and by [rechoir] for registering module loaders.
+
+## How to use it
+
+Consumers should use the exported `extensions` or `jsVariants` object to determine which module should be loaded for a given extension. If a matching extension is found, consumers should do the following:
+
+1.  If the value is null, do nothing.
+2.  If the value is a string, try to require it.
+3.  If the value is an object, try to require the `module` property. If successful, the `register` property (a function) should be called with the module passed as the first argument. **Advanced:** An optional second argument can be provided to replace the default configuration for a hook.
+4.  If the value is an array, iterate over it, attempting step #2 or #3 until one of the attempts does not throw.
+
+## API
+
+This module provides two top-level properties: `extensions` and `jsVariants`.
+
+**Note:** This module does not depend on any of the loaders it recommends; instead, end-users are expected to install the hooks they want to use for the file types they want to use. See supported extensions and their hooks in the sections below.
+
+### `extensions`
+
+A mapping of file extensions to modules which provide a [require.extensions] loader.
+
+File extension keys are all in the format of `'.foo'` or `'.foo.bar'` and module loader values are either `null` if the loader should fallthrough to node's loader,
+or a string representing the module to be required, an object of `{ module: 'foobar', register: function }`, or an array containing those strings and/or objects.
+
+A sample of an entry containing multiple hooks would look like:
+
+```js
+{
+  '.ts': [
+    'ts-node/register',
+    'sucrase/register/ts',
+    {
+      module: '@babel/register',
+      register: function(hook) {
+        hook({
+          extensions: '.ts',
+          rootMode: 'upward-optional',
+          ignore: [ignoreNonBabelAndNodeModules],
+        });
+      },
+    },
+  ],
+}
+```
+
+**Supported extensions and their hooks**
+
+```yaml file=scripts/extensions.yaml
+.babel.js:
+  - '@babel/register'
+.babel.jsx:
+  - '@babel/register'
+.babel.ts:
+  - '@babel/register'
+.babel.tsx:
+  - '@babel/register'
+.cjs:
+  - interpret/cjs-stub
+.coffee:
+  - coffeescript/register
+.coffee.md:
+  - coffeescript/register
+.cts:
+  - ts-node/register
+.esbuild.js:
+  - esbuild-register/dist/node
+.esbuild.jsx:
+  - esbuild-register/dist/node
+.esbuild.ts:
+  - esbuild-register/dist/node
+.esbuild.tsx:
+  - esbuild-register/dist/node
+.esm.js:
+  - esm
+.js:
+  - built-in node.js loader
+.json:
+  - built-in node.js loader
+.json5:
+  - json5/lib/register
+.jsx:
+  - '@babel/register'
+  - sucrase/register/jsx
+.litcoffee:
+  - coffeescript/register
+.mdx:
+  - '@mdx-js/register'
+.mjs:
+  - interpret/mjs-stub
+.node:
+  - built-in node.js loader
+.sucrase.js:
+  - sucrase/dist/register
+.sucrase.jsx:
+  - sucrase/dist/register
+.sucrase.ts:
+  - sucrase/dist/register
+.sucrase.tsx:
+  - sucrase/dist/register
+.swc.js:
+  - '@swc/register'
+.swc.jsx:
+  - '@swc/register'
+.swc.ts:
+  - '@swc/register'
+.swc.tsx:
+  - '@swc/register'
+.toml:
+  - toml-require
+.ts:
+  - ts-node/register
+  - sucrase/register/ts
+  - '@babel/register'
+  - esbuild-register/dist/node
+  - '@swc/register'
+.tsx:
+  - ts-node/register
+  - sucrase/register/tsx
+  - '@babel/register'
+  - esbuild-register/dist/node
+  - '@swc/register'
+.yaml:
+  - yaml-hook/register
+.yml:
+  - yaml-hook/register
+```
+
+### `jsVariants`
+
+The `jsVariants` is the same mapping as above, but only include the extensions which are variants of JavaScript.
+
+**Supported extensions and their hooks**
+
+```yaml file=scripts/jsVariants.yaml
+.babel.js:
+  - '@babel/register'
+.babel.jsx:
+  - '@babel/register'
+.babel.ts:
+  - '@babel/register'
+.babel.tsx:
+  - '@babel/register'
+.cjs:
+  - interpret/cjs-stub
+.coffee:
+  - coffeescript/register
+.coffee.md:
+  - coffeescript/register
+.esbuild.js:
+  - esbuild-register/dist/node
+.esbuild.jsx:
+  - esbuild-register/dist/node
+.esbuild.ts:
+  - esbuild-register/dist/node
+.esbuild.tsx:
+  - esbuild-register/dist/node
+.esm.js:
+  - esm
+.js:
+  - built-in node.js loader
+.jsx:
+  - '@babel/register'
+  - sucrase/register/jsx
+.litcoffee:
+  - coffeescript/register
+.mdx:
+  - '@mdx-js/register'
+.mjs:
+  - interpret/mjs-stub
+.sucrase.js:
+  - sucrase/dist/register
+.sucrase.jsx:
+  - sucrase/dist/register
+.sucrase.ts:
+  - sucrase/dist/register
+.sucrase.tsx:
+  - sucrase/dist/register
+.swc.js:
+  - '@swc/register'
+.swc.jsx:
+  - '@swc/register'
+.swc.ts:
+  - '@swc/register'
+.swc.tsx:
+  - '@swc/register'
+.ts:
+  - ts-node/register
+  - sucrase/register/ts
+  - '@babel/register'
+  - esbuild-register/dist/node
+  - '@swc/register'
+.tsx:
+  - ts-node/register
+  - sucrase/register/tsx
+  - '@babel/register'
+  - esbuild-register/dist/node
+  - '@swc/register'
+```
+
+## License
+
+MIT
+
+<!-- prettier-ignore-start -->
+
+[downloads-image]: https://img.shields.io/npm/dm/interpret.svg?style=flat-square
+
+[npm-url]: https://www.npmjs.com/package/interpret
+
+[npm-image]: https://img.shields.io/npm/v/interpret.svg?style=flat-square
+
+[ci-url]: https://github.com/gulpjs/interpret/actions?query=workflow:dev
+
+[ci-image]: https://img.shields.io/github/workflow/status/gulpjs/interpret/dev?style=flat-square
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/interpret
+
+[coveralls-image]: https://img.shields.io/coveralls/gulpjs/interpret/master.svg?style=flat-square
+
+<!-- prettier-ignore-end -->
+
+<!-- prettier-ignore-start -->
+
+[Liftoff]: http://github.com/gulpjs/liftoff
+
+[rechoir]: http://github.com/gulpjs/rechoir
+
+[require.extensions]: https://nodejs.org/api/modules.html#requireextensions
+
+<!-- prettier-ignore-end -->

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/cjs-stub.js

@@ -0,0 +1 @@
+require.extensions['.cjs'] = null;

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/index.js

@@ -0,0 +1,542 @@
+var path = require('path');
+
+// We only register on the final extension (like `.js`) due to https://github.com/joyent/node/blob/v0.12.0/lib/module.js#L353
+// However, we use these matchers to apply the transform only if the full extension matches
+function endsInJsx(filename) {
+  return filename.endsWith('.jsx');
+}
+function endsInTs(filename) {
+  return filename.endsWith('.ts');
+}
+function endsInTsx(filename) {
+  return filename.endsWith('.tsx');
+}
+function endsInBabelJs(filename) {
+  return filename.endsWith('.babel.js');
+}
+function endsInBabelJsx(filename) {
+  return filename.endsWith('.babel.jsx');
+}
+function endsInBabelTs(filename) {
+  return filename.endsWith('.babel.ts');
+}
+function endsInBabelTsx(filename) {
+  return filename.endsWith('.babel.tsx');
+}
+function endsInEsbuildJs(filename) {
+  return filename.endsWith('.esbuild.js');
+}
+function endsInEsbuildJsx(filename) {
+  return filename.endsWith('.esbuild.jsx');
+}
+function endsInEsbuildTs(filename) {
+  return filename.endsWith('.esbuild.ts');
+}
+function endsInEsbuildTsx(filename) {
+  return filename.endsWith('.esbuild.tsx');
+}
+function endsInSucraseJs(filename) {
+  return filename.endsWith('.sucrase.js');
+}
+function endsInSucraseJsx(filename) {
+  return filename.endsWith('.sucrase.jsx');
+}
+function endsInSucraseTs(filename) {
+  return filename.endsWith('.sucrase.ts');
+}
+function endsInSucraseTsx(filename) {
+  return filename.endsWith('.sucrase.tsx');
+}
+function endsInSwcJs(filename) {
+  return filename.endsWith('.swc.js');
+}
+function endsInSwcJsx(filename) {
+  return filename.endsWith('.swc.jsx');
+}
+function endsInSwcTs(filename) {
+  return filename.endsWith('.swc.ts');
+}
+function endsInSwcTsx(filename) {
+  return filename.endsWith('.swc.tsx');
+}
+
+var cjsStub = path.join(__dirname, 'cjs-stub');
+var mjsStub = path.join(__dirname, 'mjs-stub');
+
+function isNodeModules(file) {
+  return path.relative(process.cwd(), file).includes('node_modules');
+}
+
+var extensions = {
+  '.babel.js': {
+    module: '@babel/register',
+    register: function (hook, config) {
+      config = config || {
+        rootMode: 'upward-optional',
+        overrides: [{ only: [endsInBabelJs], presets: ['@babel/preset-env'] }],
+      };
+
+      hook(Object.assign({}, config, { extensions: '.js' }));
+    },
+  },
+  '.babel.jsx': {
+    module: '@babel/register',
+    register: function (hook, config) {
+      config = config || {
+        rootMode: 'upward-optional',
+        overrides: [
+          {
+            only: [endsInBabelJsx],
+            presets: ['@babel/preset-env', '@babel/preset-react'],
+          },
+        ],
+      };
+
+      hook(Object.assign({}, config, { extensions: '.jsx' }));
+    },
+  },
+  '.babel.ts': [
+    {
+      module: '@babel/register',
+      register: function (hook, config) {
+        config = config || {
+          rootMode: 'upward-optional',
+          overrides: [
+            {
+              only: [endsInBabelTs],
+              presets: ['@babel/preset-env', '@babel/preset-typescript'],
+            },
+          ],
+        };
+
+        hook(Object.assign({}, config, { extensions: '.ts' }));
+      },
+    },
+  ],
+  '.babel.tsx': {
+    module: '@babel/register',
+    register: function (hook, config) {
+      config = config || {
+        rootMode: 'upward-optional',
+        overrides: [
+          {
+            only: [endsInBabelTsx],
+            presets: [
+              '@babel/preset-env',
+              '@babel/preset-react',
+              [
+                '@babel/preset-typescript',
+                {
+                  isTSX: true,
+                  allExtensions: true,
+                },
+              ],
+            ],
+          },
+        ],
+      };
+
+      hook(Object.assign({}, config, { extensions: '.tsx' }));
+    },
+  },
+  '.cjs': cjsStub,
+  '.coffee': 'coffeescript/register',
+  '.coffee.md': 'coffeescript/register',
+  '.esbuild.js': {
+    module: 'esbuild-register/dist/node',
+    register: function (mod, config) {
+      config = config || {
+        target: 'node' + process.version.slice(1),
+        hookMatcher: endsInEsbuildJs,
+      };
+
+      mod.register(Object.assign({}, config, { extensions: ['.js'] }));
+    },
+  },
+  '.esbuild.jsx': {
+    module: 'esbuild-register/dist/node',
+    register: function (mod, config) {
+      config = config || {
+        target: 'node' + process.version.slice(1),
+        hookMatcher: endsInEsbuildJsx,
+      };
+
+      mod.register(Object.assign({}, config, { extensions: ['.jsx'] }));
+    },
+  },
+  '.esbuild.ts': {
+    module: 'esbuild-register/dist/node',
+    register: function (mod, config) {
+      config = config || {
+        target: 'node' + process.version.slice(1),
+        hookMatcher: endsInEsbuildTs,
+      };
+
+      mod.register(Object.assign({}, config, { extensions: ['.ts'] }));
+    },
+  },
+  '.esbuild.tsx': {
+    module: 'esbuild-register/dist/node',
+    register: function (mod, config) {
+      config = config || {
+        target: 'node' + process.version.slice(1),
+        hookMatcher: endsInEsbuildTsx,
+      };
+
+      mod.register(Object.assign({}, config, { extensions: ['.tsx'] }));
+    },
+  },
+  '.esm.js': {
+    module: 'esm',
+    register: function (hook) {
+      // register on .js extension due to https://github.com/joyent/node/blob/v0.12.0/lib/module.js#L353
+      // which only captures the final extension (.esm.js -> .js)
+      var esmLoader = hook(module);
+      require.extensions['.js'] = esmLoader('module')._extensions['.js'];
+    },
+  },
+  '.js': null,
+  '.json': null,
+  '.json5': 'json5/lib/register',
+  '.jsx': [
+    {
+      module: '@babel/register',
+      register: function (hook, config) {
+        config = config || {
+          rootMode: 'upward-optional',
+          overrides: [
+            {
+              only: [endsInJsx],
+              presets: ['@babel/preset-env', '@babel/preset-react'],
+            },
+          ],
+        };
+
+        hook(Object.assign({}, config, { extensions: '.jsx' }));
+      },
+    },
+    'sucrase/register/jsx',
+  ],
+  '.litcoffee': 'coffeescript/register',
+  // The mdx loader hooks both `.md` and `.mdx` when it is imported
+  // but we only install the hook if `.mdx` is the first file
+  '.mdx': '@mdx-js/register',
+  '.mjs': mjsStub,
+  '.node': null,
+  '.sucrase.js': {
+    module: 'sucrase/dist/register',
+    register: function (hook, config) {
+      config = config || {
+        matcher: endsInSucraseJs,
+      };
+
+      hook.registerJS(config);
+    },
+  },
+  '.sucrase.jsx': {
+    module: 'sucrase/dist/register',
+    register: function (hook, config) {
+      config = config || {
+        matcher: endsInSucraseJsx,
+      };
+
+      hook.registerJSX(config);
+    },
+  },
+  '.sucrase.ts': {
+    module: 'sucrase/dist/register',
+    register: function (hook, config) {
+      config = config || {
+        matcher: endsInSucraseTs,
+      };
+
+      hook.registerTS(config);
+    },
+  },
+  '.sucrase.tsx': {
+    module: 'sucrase/dist/register',
+    register: function (hook, config) {
+      config = config || {
+        matcher: endsInSucraseTsx,
+      };
+
+      hook.registerTSX(config);
+    },
+  },
+  '.swc.js': {
+    module: '@swc/register',
+    register: function (hook, config) {
+      config = config || {
+        only: [endsInSwcJs],
+        ignore: [isNodeModules],
+        jsc: {
+          parser: {
+            syntax: 'ecmascript',
+          },
+        },
+        module: {
+          type: 'commonjs',
+        },
+      };
+
+      hook(
+        Object.assign({}, config, {
+          extensions: '.js',
+        })
+      );
+    },
+  },
+  '.swc.jsx': {
+    module: '@swc/register',
+    register: function (hook, config) {
+      config = config || {
+        only: [endsInSwcJsx],
+        ignore: [isNodeModules],
+        jsc: {
+          parser: {
+            syntax: 'ecmascript',
+            jsx: true,
+          },
+        },
+        module: {
+          type: 'commonjs',
+        },
+      };
+
+      hook(
+        Object.assign({}, config, {
+          extensions: '.jsx',
+        })
+      );
+    },
+  },
+  '.swc.ts': {
+    module: '@swc/register',
+    register: function (hook, config) {
+      config = config || {
+        only: [endsInSwcTs],
+        ignore: [isNodeModules],
+        jsc: {
+          parser: {
+            syntax: 'typescript',
+          },
+        },
+        module: {
+          type: 'commonjs',
+        },
+      };
+
+      hook(
+        Object.assign({}, config, {
+          extensions: '.ts',
+        })
+      );
+    },
+  },
+  '.swc.tsx': {
+    module: '@swc/register',
+    register: function (hook, config) {
+      config = config || {
+        only: [endsInSwcTsx],
+        ignore: [isNodeModules],
+        jsc: {
+          parser: {
+            syntax: 'typescript',
+            tsx: true,
+          },
+        },
+        module: {
+          type: 'commonjs',
+        },
+      };
+
+      hook(
+        Object.assign({}, config, {
+          extensions: '.tsx',
+        })
+      );
+    },
+  },
+  '.toml': {
+    module: 'toml-require',
+    register: function (hook, config) {
+      hook.install(config);
+    },
+  },
+  '.ts': [
+    'ts-node/register',
+    'sucrase/register/ts',
+    {
+      module: '@babel/register',
+      register: function (hook, config) {
+        config = config || {
+          rootMode: 'upward-optional',
+          overrides: [
+            {
+              only: [endsInTs],
+              presets: ['@babel/preset-env', '@babel/preset-typescript'],
+            },
+          ],
+        };
+
+        hook(
+          Object.assign({}, config, {
+            extensions: '.ts',
+          })
+        );
+      },
+    },
+    {
+      module: 'esbuild-register/dist/node',
+      register: function (mod, config) {
+        config = config || {
+          target: 'node' + process.version.slice(1),
+          hookMatcher: endsInTs,
+        };
+
+        mod.register(
+          Object.assign({}, config, {
+            extensions: ['.ts'],
+          })
+        );
+      },
+    },
+    {
+      module: '@swc/register',
+      register: function (hook, config) {
+        config = config || {
+          only: [endsInTs],
+          ignore: [isNodeModules],
+          jsc: {
+            parser: {
+              syntax: 'typescript',
+            },
+          },
+          module: {
+            type: 'commonjs',
+          },
+        };
+
+        hook(
+          Object.assign({}, config, {
+            extensions: '.ts',
+          })
+        );
+      },
+    },
+  ],
+  '.cts': ['ts-node/register'],
+  '.tsx': [
+    'ts-node/register',
+    'sucrase/register/tsx',
+    {
+      module: '@babel/register',
+      register: function (hook, config) {
+        config = config || {
+          rootMode: 'upward-optional',
+          overrides: [
+            {
+              only: [endsInTsx],
+              presets: [
+                '@babel/preset-env',
+                '@babel/preset-react',
+                [
+                  '@babel/preset-typescript',
+                  {
+                    isTSX: true,
+                    allExtensions: true,
+                  },
+                ],
+              ],
+            },
+          ],
+        };
+
+        hook(
+          Object.assign({}, config, {
+            extensions: '.tsx',
+          })
+        );
+      },
+    },
+    {
+      module: 'esbuild-register/dist/node',
+      register: function (mod, config) {
+        config = config || {
+          target: 'node' + process.version.slice(1),
+          hookMatcher: endsInTsx,
+        };
+
+        mod.register(
+          Object.assign({}, config, {
+            extensions: ['.tsx'],
+          })
+        );
+      },
+    },
+    {
+      module: '@swc/register',
+      register: function (hook, config) {
+        config = config || {
+          only: [endsInTsx],
+          ignore: [isNodeModules],
+          jsc: {
+            parser: {
+              syntax: 'typescript',
+              tsx: true,
+            },
+          },
+          module: {
+            type: 'commonjs',
+          },
+        };
+
+        hook(
+          Object.assign({}, config, {
+            extensions: '.tsx',
+          })
+        );
+      },
+    },
+  ],
+  '.yaml': 'yaml-hook/register',
+  '.yml': 'yaml-hook/register',
+};
+
+var jsVariantExtensions = [
+  '.js',
+  '.babel.js',
+  '.babel.jsx',
+  '.babel.ts',
+  '.babel.tsx',
+  '.esbuild.js',
+  '.esbuild.jsx',
+  '.esbuild.ts',
+  '.esbuild.tsx',
+  '.cjs',
+  '.coffee',
+  '.coffee.md',
+  '.esm.js',
+  '.jsx',
+  '.litcoffee',
+  '.mdx',
+  '.mjs',
+  '.sucrase.js',
+  '.sucrase.jsx',
+  '.sucrase.ts',
+  '.sucrase.tsx',
+  '.swc.js',
+  '.swc.jsx',
+  '.swc.ts',
+  '.swc.tsx',
+  '.ts',
+  '.tsx',
+];
+
+module.exports = {
+  extensions: extensions,
+  jsVariants: jsVariantExtensions.reduce(function (result, ext) {
+    result[ext] = extensions[ext];
+    return result;
+  }, {}),
+};

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/mjs-stub.js

@@ -0,0 +1 @@
+require.extensions['.mjs'] = null;

build_vtk_bundle/node_modules/webpack-cli/node_modules/interpret/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "interpret",
+  "version": "3.1.1",
+  "description": "A dictionary of file extensions and associated module loaders.",
+  "author": "Gulp Team <team@gulpjs.com> (https://gulpjs.com/)",
+  "contributors": [
+    "Blaine Bublitz <blaine.bublitz@gmail.com>",
+    "Tyler Kellen <tyler@sleekcode.net> (http://goingslowly.com/)"
+  ],
+  "repository": "gulpjs/interpret",
+  "license": "MIT",
+  "engines": {
+    "node": ">=10.13.0"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js",
+    "cjs-stub.js",
+    "mjs-stub.js"
+  ],
+  "scripts": {
+    "readme": "remark README.md --use ./scripts/plugin.mjs --output",
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "nyc mocha --async-only"
+  },
+  "devDependencies": {
+    "eslint": "^7.0.0",
+    "eslint-config-gulp": "^5.0.0",
+    "eslint-plugin-node": "^11.1.0",
+    "expect": "^27.0.0",
+    "js-yaml": "^4.1.0",
+    "mocha": "^8.0.0",
+    "nyc": "^15.0.0",
+    "parse-node-version": "^2.0.0",
+    "rechoir": "^0.8.0",
+    "remark-cli": "^10.0.1",
+    "remark-code-import": "^1.1.0",
+    "shelljs": "0.8.5"
+  },
+  "nyc": {
+    "extension": [
+      ".js"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "keywords": [
+    "coffee",
+    "coffee.md",
+    "coffeescript",
+    "es",
+    "es6",
+    "js",
+    "json",
+    "json5",
+    "jsx",
+    "react",
+    "litcoffee",
+    "toml",
+    "ts",
+    "typescript",
+    "xml",
+    "yaml",
+    "yml"
+  ]
+}

build_vtk_bundle/node_modules/webpack-cli/node_modules/rechoir/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.8.0](https://www.github.com/gulpjs/rechoir/compare/v0.7.1...v0.8.0) (2021-07-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* Normalize repository, dropping node <10.13 support (#40)
+
+### Miscellaneous Chores
+
+* Normalize repository, dropping node <10.13 support ([#40](https://www.github.com/gulpjs/rechoir/issues/40)) ([00f5968](https://www.github.com/gulpjs/rechoir/commit/00f59689d0eb9668d939a85e06428a0906587a6f))

build_vtk_bundle/node_modules/webpack-cli/node_modules/rechoir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2019, 2021 Tyler Kellen <tyler@sleekcode.net>, Blaine Bublitz <blaine.bublitz@gmail.com>, and Eric Schoffstall <yo@contra.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

build_vtk_bundle/node_modules/webpack-cli/node_modules/rechoir/README.md

@@ -0,0 +1,73 @@
+<p align="center">
+  <a href="http://gulpjs.com">
+    <img height="257" width="114" src="https://raw.githubusercontent.com/gulpjs/artwork/master/gulp-2x.png">
+  </a>
+</p>
+
+# rechoir
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][ci-image]][ci-url] [![Coveralls Status][coveralls-image]][coveralls-url]
+
+Prepare a node environment to require files with different extensions.
+
+## What is it?
+
+This module, in conjunction with [interpret]-like objects, can register any filetype the npm ecosystem has a module loader for. This library is a dependency of [liftoff].
+
+**Note:** While `rechoir` will automatically load and register transpilers like `coffee-script`, you must provide a local installation. The transpilers are **not** bundled with this module.
+
+## Usage
+
+```js
+const config = require('interpret').extensions;
+const rechoir = require('rechoir');
+rechoir.prepare(config, './test/fixtures/test.coffee');
+rechoir.prepare(config, './test/fixtures/test.csv');
+rechoir.prepare(config, './test/fixtures/test.toml');
+
+console.log(require('./test/fixtures/test.coffee'));
+console.log(require('./test/fixtures/test.csv'));
+console.log(require('./test/fixtures/test.toml'));
+```
+
+## API
+
+### `prepare(config, filepath, [cwd], [noThrow])`
+
+Look for a module loader associated with the provided file and attempt require it. If necessary, run any setup required to inject it into [require.extensions].
+
+`config` An [interpret]-like configuration object.
+
+`filepath` A file whose type you'd like to register a module loader for.
+
+`cwd` An optional path to start searching for the module required to load the requested file. Defaults to the directory of `filepath`.
+
+`noThrow` An optional boolean indicating if the method should avoid throwing.
+
+If calling this method is successful (e.g. it doesn't throw), you can now require files of the type you requested natively.
+
+An error with a `failures` property will be thrown if the module loader(s) configured for a given extension cannot be registered.
+
+If a loader is already registered, this will simply return `true`.
+
+## License
+
+MIT
+
+<!-- prettier-ignore-start -->
+[downloads-image]: https://img.shields.io/npm/dm/rechoir.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/rechoir
+[npm-image]: https://img.shields.io/npm/v/rechoir.svg?style=flat-square
+
+[ci-url]: https://github.com/gulpjs/rechoir/actions?query=workflow:dev
+[ci-image]: https://img.shields.io/github/workflow/status/gulpjs/rechoir/dev?style=flat-square
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/rechoir
+[coveralls-image]: https://img.shields.io/coveralls/gulpjs/rechoir/master.svg
+<!-- prettier-ignore-end -->
+
+<!-- prettier-ignore-start -->
+[interpret]: https://github.com/gulpjs/interpret
+[require.extensions]: https://nodejs.org/api/modules.html#modules_require_extensions
+[liftoff]: https://github.com/js-cli/js-liftoff
+<!-- prettier-ignore-end -->

build_vtk_bundle/node_modules/webpack-cli/node_modules/rechoir/index.js

@@ -0,0 +1,69 @@
+var path = require('path');
+
+var extension = require('./lib/extension');
+var normalize = require('./lib/normalize');
+var register = require('./lib/register');
+
+exports.prepare = function (extensions, filepath, cwd, nothrow) {
+  var config, usedExtension, err, option, attempt, error;
+  var attempts = [];
+  var onlyErrors = true;
+  var exts = extension(filepath);
+
+  if (exts) {
+    exts.some(function (ext) {
+      usedExtension = ext;
+      config = normalize(extensions[ext]);
+      return !!config;
+    });
+  }
+
+  if (Object.keys(require.extensions).indexOf(usedExtension) !== -1) {
+    return true;
+  }
+
+  if (!config) {
+    if (nothrow) {
+      return;
+    }
+
+    throw new Error('No module loader found for "' + usedExtension + '".');
+  }
+
+  if (!cwd) {
+    cwd = path.dirname(path.resolve(filepath));
+  }
+  if (!Array.isArray(config)) {
+    config = [config];
+  }
+
+  for (var i in config) {
+    option = config[i];
+    attempt = register(cwd, option.module, option.register);
+    error = attempt instanceof Error ? attempt : null;
+    if (error) {
+      attempt = null;
+    }
+    attempts.push({
+      moduleName: option.module,
+      module: attempt,
+      error: error,
+    });
+    if (!error) {
+      onlyErrors = false;
+      break;
+    }
+  }
+  if (onlyErrors) {
+    err = new Error(
+      'Unable to use specified module loaders for "' + usedExtension + '".'
+    );
+    err.failures = attempts;
+    if (nothrow) {
+      return err;
+    }
+
+    throw err;
+  }
+  return attempts;
+};

build_vtk_bundle/node_modules/webpack-cli/node_modules/rechoir/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "rechoir",
+  "version": "0.8.0",
+  "description": "Prepare a node environment to require files with different extensions.",
+  "author": "Gulp Team <team@gulpjs.com> (http://gulpjs.com/)",
+  "contributors": [
+    "Blaine Bublitz <blaine.bublitz@gmail.com>",
+    "Tyler Kellen <tyler@sleekcode.net> (http://goingslowly.com/)"
+  ],
+  "repository": "gulpjs/rechoir",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js",
+    "lib/"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "rm -rf tmp/ && npm run lint",
+    "test": "nyc mocha --async-only"
+  },
+  "dependencies": {
+    "resolve": "^1.20.0"
+  },
+  "devDependencies": {
+    "eslint": "^7.21.0",
+    "eslint-config-gulp": "^5.0.1",
+    "expect": "^27.0.0",
+    "mocha": "^8.3.0",
+    "nyc": "^15.1.0"
+  },
+  "nyc": {
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "keywords": [
+    "require",
+    "loader",
+    "extension",
+    "extensions",
+    "prepare"
+  ]
+}