first

node_modules/html-minifier-terser/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010-2019 Juriy "kangax" Zaytsev
+
+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.

node_modules/html-minifier-terser/README.md

@@ -0,0 +1,166 @@
+# HTMLMinifier
+
+[![NPM version](https://img.shields.io/npm/v/html-minifier-terser.svg)](https://www.npmjs.com/package/html-minifier-terser)
+[![Build Status](https://github.com/terser/html-minifier-terser/workflows/CI/badge.svg)](https://github.com/terser/html-minifier-terser/actions?workflow=CI)
+
+[HTMLMinifier](https://terser.org/html-minifier-terser/) is a highly **configurable**, **well-tested**, JavaScript-based HTML minifier.
+
+See [corresponding blog post](http://perfectionkills.com/experimenting-with-html-minifier/) for all the gory details of [how it works](http://perfectionkills.com/experimenting-with-html-minifier/#how_it_works), [description of each option](http://perfectionkills.com/experimenting-with-html-minifier/#options), [testing results](http://perfectionkills.com/experimenting-with-html-minifier/#field_testing) and [conclusions](http://perfectionkills.com/experimenting-with-html-minifier/#cost_and_benefits).
+
+[Test suite is available online](https://terser.org/html-minifier-terser/tests/).
+
+Also see corresponding [Ruby wrapper](https://github.com/stereobooster/html_minifier), and for Node.js, [Grunt plugin](https://github.com/gruntjs/grunt-contrib-htmlmin), [Gulp module](https://github.com/jonschlinkert/gulp-htmlmin), [Koa middleware wrapper](https://github.com/koajs/html-minifier) and [Express middleware wrapper](https://github.com/melonmanchan/express-minify-html).
+
+For lint-like capabilities take a look at [HTMLLint](https://github.com/kangax/html-lint).
+
+## Minification comparison
+
+How does HTMLMinifier compare to other solutions — [HTML Minifier from Will Peavy](http://www.willpeavy.com/minifier/) (1st result in [Google search for "html minifier"](https://www.google.com/#q=html+minifier)) as well as [htmlcompressor.com](http://htmlcompressor.com) and [minimize](https://github.com/Swaagie/minimize)?
+
+| Site                                                                         | Original size *(KB)* | HTMLMinifier | minimize | Will Peavy | htmlcompressor.com |
+| ---------------------------------------------------------------------------- |:--------------------:| ------------:| --------:| ----------:| ------------------:|
+| [Google](https://www.google.com/)                                            | 45                   | **41**       | 45       | 46         | 45                 |
+| [Stack Overflow](https://stackoverflow.com/)                                 | 115                  | **82**       | 90       | 92         | 88                 |
+| [HTMLMinifier](https://github.com/kangax/html-minifier)                      | 132                  | **105**      | 118      | 123        | 118                |
+| [Bootstrap CSS](https://getbootstrap.com/docs/3.3/css/)                      | 271                  | **260**      | 269      | 229        | 269                |
+| [Twitter](https://twitter.com/)                                              | 289                  | **238**      | 282      | 314        | 282                |
+| [BBC](https://www.bbc.co.uk/)                                                | 298                  | **233**      | 289      | 291        | 269                |
+| [Wikipedia](https://en.wikipedia.org/wiki/President_of_the_United_States)    | 574                  | **468**      | 557      | 578        | 557                |
+| [Amazon](https://www.amazon.co.uk/)                                          | 702                  | **343**      | 692      | 704        | n/a                |
+| [NBC](https://www.nbc.com/)                                                  | 844                  | **805**      | 843      | 844        | n/a                |
+| [Eloquent Javascript](https://eloquentjavascript.net/1st_edition/print.html) | 870                  | **815**      | 840      | 864        | n/a                |
+| [New York Times](https://www.nytimes.com/)                                   | 1304                 | **1183**     | 1301     | 1295       | n/a                |
+| [ES draft](https://tc39.github.io/ecma262/)                                  | 6347                 | **5686**     | 5863     | n/a        | n/a                |
+
+## Options Quick Reference
+
+Most of the options are disabled by default.
+
+| Option                         | Description     | Default |
+|--------------------------------|-----------------|---------|
+| `caseSensitive`                | Treat attributes in case sensitive manner (useful for custom HTML tags) | `false` |
+| `collapseBooleanAttributes`    | [Omit attribute values from boolean attributes](http://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes) | `false` |
+| `collapseInlineTagWhitespace`  | Don't leave any spaces between `display:inline;` elements when collapsing. Must be used in conjunction with `collapseWhitespace=true` | `false` |
+| `collapseWhitespace`           | [Collapse white space that contributes to text nodes in a document tree](http://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace) | `false` |
+| `conservativeCollapse`         | Always collapse to 1 space (never remove it entirely). Must be used in conjunction with `collapseWhitespace=true` | `false` |
+| `continueOnParseError`         | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting. | `false` |
+| `customAttrAssign`             | Arrays of regex'es that allow to support custom attribute assign expressions (e.g. `'<div flex?="{{mode != cover}}"></div>'`) | `[ ]` |
+| `customAttrCollapse`           | Regex that specifies custom attribute to strip newlines from (e.g. `/ng-class/`) | |
+| `customAttrSurround`           | Arrays of regex'es that allow to support custom attribute surround expressions (e.g. `<input {{#if value}}checked="checked"{{/if}}>`) | `[ ]` |
+| `customEventAttributes`        | Arrays of regex'es that allow to support custom event attributes for `minifyJS` (e.g. `ng-click`) | `[ /^on[a-z]{3,}$/ ]` |
+| `decodeEntities`               | Use direct Unicode characters whenever possible | `false` |
+| `html5`                        | Parse input according to HTML5 specifications | `true` |
+| `ignoreCustomComments`         | Array of regex'es that allow to ignore certain comments, when matched | `[ /^!/, /^\s*#/ ]` |
+| `ignoreCustomFragments`        | Array of regex'es that allow to ignore certain fragments, when matched (e.g. `<?php ... ?>`, `{{ ... }}`, etc.)  | `[ /<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/ ]` |
+| `includeAutoGeneratedTags`     | Insert tags generated by HTML parser | `true` |
+| `keepClosingSlash`             | Keep the trailing slash on singleton elements | `false` |
+| `maxLineLength`                | Specify a maximum line length. Compressed output will be split by newlines at valid HTML split-points |
+| `minifyCSS`                    | Minify CSS in style elements and style attributes (uses [clean-css](https://github.com/jakubpawlowicz/clean-css)) | `false` (could be `true`, `Object`, `Function(text, type)`) |
+| `minifyJS`                     | Minify JavaScript in script elements and event attributes (uses [Terser](https://github.com/terser/terser)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
+| `minifyURLs`                   | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `String`, `Object`, `Function(text)`) |
+| `noNewlinesBeforeTagClose`     | Never add a newline before a tag that closes an element | `false` |
+| `preserveLineBreaks`           | Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break. Must be used in conjunction with `collapseWhitespace=true` | `false` |
+| `preventAttributesEscaping`    | Prevents the escaping of the values of attributes | `false` |
+| `processConditionalComments`   | Process contents of conditional comments through minifier | `false` |
+| `processScripts`               | Array of strings corresponding to types of script elements to process through minifier (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.) | `[ ]` |
+| `quoteCharacter`               | Type of quote to use for attribute values (' or ") | |
+| `removeAttributeQuotes`        | [Remove quotes around attributes when possible](http://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes) | `false` |
+| `removeComments`               | [Strip HTML comments](http://perfectionkills.com/experimenting-with-html-minifier/#remove_comments) | `false` |
+| `removeEmptyAttributes`        | [Remove all attributes with whitespace-only values](http://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_or_blank_attributes) | `false` (could be `true`, `Function(attrName, tag)`) |
+| `removeEmptyElements`          | [Remove all elements with empty contents](http://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_elements) | `false` |
+| `removeOptionalTags`           | [Remove optional tags](http://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags) | `false` |
+| `removeRedundantAttributes`    | [Remove attributes when value matches default.](http://perfectionkills.com/experimenting-with-html-minifier/#remove_redundant_attributes) | `false` |
+| `removeScriptTypeAttributes`   | Remove `type="text/javascript"` from `script` tags. Other `type` attribute values are left intact | `false` |
+| `removeStyleLinkTypeAttributes`| Remove `type="text/css"` from `style` and `link` tags. Other `type` attribute values are left intact | `false` |
+| `removeTagWhitespace`          | Remove space between attributes whenever possible. **Note that this will result in invalid HTML!** | `false` |
+| `sortAttributes`               | [Sort attributes by frequency](#sorting-attributes--style-classes) | `false` |
+| `sortClassName`                | [Sort style classes by frequency](#sorting-attributes--style-classes) | `false` |
+| `trimCustomFragments`          | Trim white space around `ignoreCustomFragments`. | `false` |
+| `useShortDoctype`              | [Replaces the `doctype` with the short (HTML5) doctype](http://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype) | `false` |
+
+### Sorting attributes / style classes
+
+Minifier options like `sortAttributes` and `sortClassName` won't impact the plain-text size of the output. However, they form long repetitive chains of characters that should improve compression ratio of gzip used in HTTP compression.
+
+## Special cases
+
+### Ignoring chunks of markup
+
+If you have chunks of markup you would like preserved, you can wrap them `<!-- htmlmin:ignore -->`.
+
+### Preserving SVG tags
+
+SVG tags are automatically recognized, and when they are minified, both case-sensitivity and closing-slashes are preserved, regardless of the minification settings used for the rest of the file.
+
+### Working with invalid markup
+
+HTMLMinifier **can't work with invalid or partial chunks of markup**. This is because it parses markup into a tree structure, then modifies it (removing anything that was specified for removal, ignoring anything that was specified to be ignored, etc.), then it creates a markup out of that tree and returns it.
+
+Input markup (e.g. `<p id="">foo`)
+
+↓
+
+Internal representation of markup in a form of tree (e.g. `{ tag: "p", attr: "id", children: ["foo"] }`)
+
+↓
+
+Transformation of internal representation (e.g. removal of `id` attribute)
+
+↓
+
+Output of resulting markup (e.g. `<p>foo</p>`)
+
+HTMLMinifier can't know that original markup was only half of the tree; it does its best to try to parse it as a full tree and it loses information about tree being malformed or partial in the beginning. As a result, it can't create a partial/malformed tree at the time of the output.
+
+## Installation Instructions
+
+From NPM for use as a command line app:
+
+```shell
+npm install html-minifier-terser -g
+```
+
+From NPM for programmatic use:
+
+```shell
+npm install html-minifier-terser
+```
+
+From Git:
+
+```shell
+git clone git://github.com/terser/html-minifier-terser.git
+cd html-minifier-terser
+npm link .
+```
+
+## Usage
+
+Note that almost all options are disabled by default. For command line usage please see `html-minifier-terser --help` for a list of available options. Experiment and find what works best for you and your project.
+
+- **Sample command line:** `html-minifier-terser --collapse-whitespace --remove-comments --remove-optional-tags --remove-redundant-attributes --remove-script-type-attributes --remove-tag-whitespace --use-short-doctype --minify-css true --minify-js true`
+
+### Node.js
+
+```js
+const { minify } = require('html-minifier-terser');
+
+const result = await minify('<p title="blah" id="moo">foo</p>', {
+  removeAttributeQuotes: true
+});
+result; // '<p title=blah id=moo>foo</p>'
+```
+
+## Running benchmarks
+
+Benchmarks for minified HTML:
+
+```shell
+node benchmark.js
+```
+
+## Running local server
+
+```shell
+npm run serve
+```

node_modules/html-minifier-terser/cli.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * html-minifier-terser CLI tool
+ *
+ * The MIT License (MIT)
+ *
+ *  Copyright (c) 2014-2016 Zoltan Frombach
+ *
+ *  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.
+ *
+ */
+
+'use strict';
+
+var camelCase = require('camel-case').camelCase;
+var fs = require('fs');
+var info = require('./package.json');
+var minify = require('./' + info.main).minify;
+var paramCase = require('param-case').paramCase;
+var path = require('path');
+var { Command } = require('commander');
+
+const program = new Command();
+program.name(info.name);
+program.version(info.version);
+
+function fatal(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+/**
+ * JSON does not support regexes, so, e.g., JSON.parse() will not create
+ * a RegExp from the JSON value `[ "/matchString/" ]`, which is
+ * technically just an array containing a string that begins and end with
+ * a forward slash. To get a RegExp from a JSON string, it must be
+ * constructed explicitly in JavaScript.
+ *
+ * The likelihood of actually wanting to match text that is enclosed in
+ * forward slashes is probably quite rare, so if forward slashes were
+ * included in an argument that requires a regex, the user most likely
+ * thought they were part of the syntax for specifying a regex.
+ *
+ * In the unlikely case that forward slashes are indeed desired in the
+ * search string, the user would need to enclose the expression in a
+ * second set of slashes:
+ *
+ *    --customAttrSrround "[\"//matchString//\"]"
+ */
+function parseRegExp(value) {
+  if (value) {
+    return new RegExp(value.replace(/^\/(.*)\/$/, '$1'));
+  }
+}
+
+function parseJSON(value) {
+  if (value) {
+    try {
+      return JSON.parse(value);
+    }
+    catch (e) {
+      if (/^{/.test(value)) {
+        fatal('Could not parse JSON value \'' + value + '\'');
+      }
+      return value;
+    }
+  }
+}
+
+function parseJSONArray(value) {
+  if (value) {
+    value = parseJSON(value);
+    return Array.isArray(value) ? value : [value];
+  }
+}
+
+function parseJSONRegExpArray(value) {
+  value = parseJSONArray(value);
+  return value && value.map(parseRegExp);
+}
+
+function parseString(value) {
+  return value;
+}
+
+var mainOptions = {
+  caseSensitive: 'Treat attributes in case sensitive manner (useful for SVG; e.g. viewBox)',
+  collapseBooleanAttributes: 'Omit attribute values from boolean attributes',
+  collapseInlineTagWhitespace: 'Collapse white space around inline tag',
+  collapseWhitespace: 'Collapse white space that contributes to text nodes in a document tree.',
+  conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)',
+  continueOnParseError: 'Handle parse errors instead of aborting',
+  customAttrAssign: ['Arrays of regex\'es that allow to support custom attribute assign expressions (e.g. \'<div flex?="{{mode != cover}}"></div>\')', parseJSONRegExpArray],
+  customAttrCollapse: ['Regex that specifies custom attribute to strip newlines from (e.g. /ng-class/)', parseRegExp],
+  customAttrSurround: ['Arrays of regex\'es that allow to support custom attribute surround expressions (e.g. <input {{#if value}}checked="checked"{{/if}}>)', parseJSONRegExpArray],
+  customEventAttributes: ['Arrays of regex\'es that allow to support custom event attributes for minifyJS (e.g. ng-click)', parseJSONRegExpArray],
+  decodeEntities: 'Use direct Unicode characters whenever possible',
+  html5: 'Parse input according to HTML5 specifications',
+  ignoreCustomComments: ['Array of regex\'es that allow to ignore certain comments, when matched', parseJSONRegExpArray],
+  ignoreCustomFragments: ['Array of regex\'es that allow to ignore certain fragments, when matched (e.g. <?php ... ?>, {{ ... }})', parseJSONRegExpArray],
+  includeAutoGeneratedTags: 'Insert tags generated by HTML parser',
+  keepClosingSlash: 'Keep the trailing slash on singleton elements',
+  maxLineLength: ['Max line length', parseInt],
+  minifyCSS: ['Minify CSS in style elements and style attributes (uses clean-css)', parseJSON],
+  minifyJS: ['Minify Javascript in script elements and on* attributes (uses terser)', parseJSON],
+  minifyURLs: ['Minify URLs in various attributes (uses relateurl)', parseJSON],
+  noNewlinesBeforeTagClose: 'Never add a newline before a tag that closes an element',
+  preserveLineBreaks: 'Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break.',
+  preventAttributesEscaping: 'Prevents the escaping of the values of attributes.',
+  processConditionalComments: 'Process contents of conditional comments through minifier',
+  processScripts: ['Array of strings corresponding to types of script elements to process through minifier (e.g. "text/ng-template", "text/x-handlebars-template", etc.)', parseJSONArray],
+  quoteCharacter: ['Type of quote to use for attribute values (\' or ")', parseString],
+  removeAttributeQuotes: 'Remove quotes around attributes when possible.',
+  removeComments: 'Strip HTML comments',
+  removeEmptyAttributes: 'Remove all attributes with whitespace-only values',
+  removeEmptyElements: 'Remove all elements with empty contents',
+  removeOptionalTags: 'Remove unrequired tags',
+  removeRedundantAttributes: 'Remove attributes when value matches default.',
+  removeScriptTypeAttributes: 'Removes the following attributes from script tags: text/javascript, text/ecmascript, text/jscript, application/javascript, application/x-javascript, application/ecmascript. Other type attribute values are left intact',
+  removeStyleLinkTypeAttributes: 'Remove type="text/css" from style and link tags. Other type attribute values are left intact.',
+  removeTagWhitespace: 'Remove space between attributes whenever possible',
+  sortAttributes: 'Sort attributes by frequency',
+  sortClassName: 'Sort style classes by frequency',
+  trimCustomFragments: 'Trim white space around ignoreCustomFragments.',
+  useShortDoctype: 'Replaces the doctype with the short (HTML5) doctype'
+};
+var mainOptionKeys = Object.keys(mainOptions);
+mainOptionKeys.forEach(function(key) {
+  var option = mainOptions[key];
+  if (Array.isArray(option)) {
+    key = key === 'minifyURLs' ? '--minify-urls' : '--' + paramCase(key);
+    key += option[1] === parseJSON ? ' [value]' : ' <value>';
+    program.option(key, option[0], option[1]);
+  }
+  else if (~['html5', 'includeAutoGeneratedTags'].indexOf(key)) {
+    program.option('--no-' + paramCase(key), option);
+  }
+  else {
+    program.option('--' + paramCase(key), option);
+  }
+});
+program.option('-o --output <file>', 'Specify output file (if not specified STDOUT will be used for output)');
+
+function readFile(file) {
+  try {
+    return fs.readFileSync(file, { encoding: 'utf8' });
+  }
+  catch (e) {
+    fatal('Cannot read ' + file + '\n' + e.message);
+  }
+}
+
+var config = {};
+program.option('-c --config-file <file>', 'Use config file', function(configPath) {
+  var data = readFile(configPath);
+  try {
+    config = JSON.parse(data);
+  }
+  catch (je) {
+    try {
+      config = require(path.resolve(configPath));
+    }
+    catch (ne) {
+      fatal('Cannot read the specified config file.\nAs JSON: ' + je.message + '\nAs module: ' + ne.message);
+    }
+  }
+  mainOptionKeys.forEach(function(key) {
+    if (key in config) {
+      var option = mainOptions[key];
+      if (Array.isArray(option)) {
+        var value = config[key];
+        config[key] = option[1](typeof value === 'string' ? value : JSON.stringify(value));
+      }
+    }
+  });
+});
+program.option('--input-dir <dir>', 'Specify an input directory');
+program.option('--output-dir <dir>', 'Specify an output directory');
+program.option('--file-ext <text>', 'Specify an extension to be read, ex: html');
+var content;
+program.arguments('[files...]').action(function(files) {
+  content = files.map(readFile).join('');
+}).parse(process.argv);
+
+const programOptions = program.opts();
+
+function createOptions() {
+  var options = {};
+  mainOptionKeys.forEach(function(key) {
+    var param = programOptions[key === 'minifyURLs' ? 'minifyUrls' : camelCase(key)];
+    if (typeof param !== 'undefined') {
+      options[key] = param;
+    }
+    else if (key in config) {
+      options[key] = config[key];
+    }
+  });
+  return options;
+}
+
+function mkdir(outputDir, callback) {
+  fs.mkdir(outputDir, function(err) {
+    if (err) {
+      switch (err.code) {
+        case 'ENOENT':
+          return mkdir(path.join(outputDir, '..'), function() {
+            mkdir(outputDir, callback);
+          });
+        case 'EEXIST':
+          break;
+        default:
+          fatal('Cannot create directory ' + outputDir + '\n' + err.message);
+      }
+    }
+    callback();
+  });
+}
+
+function processFile(inputFile, outputFile) {
+  fs.readFile(inputFile, { encoding: 'utf8' }, async function(err, data) {
+    if (err) {
+      fatal('Cannot read ' + inputFile + '\n' + err.message);
+    }
+    var minified;
+    try {
+      minified = await minify(data, createOptions());
+    }
+    catch (e) {
+      fatal('Minification error on ' + inputFile + '\n' + e.message);
+    }
+    fs.writeFile(outputFile, minified, { encoding: 'utf8' }, function(err) {
+      if (err) {
+        fatal('Cannot write ' + outputFile + '\n' + err.message);
+      }
+    });
+  });
+}
+
+function processDirectory(inputDir, outputDir, fileExt) {
+  fs.readdir(inputDir, function(err, files) {
+    if (err) {
+      fatal('Cannot read directory ' + inputDir + '\n' + err.message);
+    }
+    files.forEach(function(file) {
+      var inputFile = path.join(inputDir, file);
+      var outputFile = path.join(outputDir, file);
+      fs.stat(inputFile, function(err, stat) {
+        if (err) {
+          fatal('Cannot read ' + inputFile + '\n' + err.message);
+        }
+        else if (stat.isDirectory()) {
+          processDirectory(inputFile, outputFile, fileExt);
+        }
+        else if (!fileExt || path.extname(file) === '.' + fileExt) {
+          mkdir(outputDir, function() {
+            processFile(inputFile, outputFile);
+          });
+        }
+      });
+    });
+  });
+}
+
+async function writeMinify() {
+  var minified;
+  try {
+    minified = await minify(content, createOptions());
+  }
+  catch (e) {
+    fatal('Minification error:\n' + e.message);
+  }
+  (programOptions.output ? fs.createWriteStream(programOptions.output).on('error', function(e) {
+    fatal('Cannot write ' + programOptions.output + '\n' + e.message);
+  }) : process.stdout).write(minified);
+}
+
+var inputDir = programOptions.inputDir;
+var outputDir = programOptions.outputDir;
+var fileExt = programOptions.fileExt;
+if (inputDir || outputDir) {
+  if (!inputDir) {
+    fatal('The option output-dir needs to be used with the option input-dir. If you are working with a single file, use -o.');
+  }
+  else if (!outputDir) {
+    fatal('You need to specify where to write the output files with the option --output-dir');
+  }
+  processDirectory(inputDir, outputDir, fileExt);
+}
+// Minifying one or more files specified on the CMD line
+else if (content) {
+  writeMinify();
+}
+// Minifying input coming from STDIN
+else {
+  content = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', function(data) {
+    content += data;
+  }).on('end', writeMinify);
+}

node_modules/html-minifier-terser/node_modules/.bin/he

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../he/bin/he" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../he/bin/he" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/html-minifier-terser/node_modules/.bin/he.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\he\bin\he" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\he\bin\he" %*
+)

node_modules/html-minifier-terser/node_modules/.bin/terser

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../terser/bin/terser" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../terser/bin/terser" "$@"
+  ret=$?
+fi
+exit $ret

node_modules/html-minifier-terser/node_modules/.bin/terser.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\terser\bin\terser" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\terser\bin\terser" %*
+)

node_modules/html-minifier-terser/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.

node_modules/html-minifier-terser/node_modules/commander/esm.mjs

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

node_modules/html-minifier-terser/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;

node_modules/html-minifier-terser/node_modules/commander/lib/argument.js

@@ -0,0 +1,147 @@
+const { InvalidArgumentError } = require('./error.js');
+
+// @ts-check
+
+class Argument {
+  /**
+   * 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.
+   *
+   * @param {string} name
+   * @param {string} [description]
+   */
+
+  constructor(name, description) {
+    this.description = description || '';
+    this.variadic = false;
+    this.parseArg = undefined;
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.argChoices = undefined;
+
+    switch (name[0]) {
+      case '<': // e.g. <required>
+        this.required = true;
+        this._name = name.slice(1, -1);
+        break;
+      case '[': // e.g. [optional]
+        this.required = false;
+        this._name = name.slice(1, -1);
+        break;
+      default:
+        this.required = true;
+        this._name = name;
+        break;
+    }
+
+    if (this._name.length > 3 && this._name.slice(-3) === '...') {
+      this.variadic = true;
+      this._name = this._name.slice(0, -3);
+    }
+  }
+
+  /**
+   * Return argument name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    return this._name;
+  };
+
+  /**
+   * @api private
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {any} value
+   * @param {string} [description]
+   * @return {Argument}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  };
+
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   *
+   * @param {Function} [fn]
+   * @return {Argument}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  };
+
+  /**
+   * Only allow option value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Argument}
+   */
+
+  choices(values) {
+    this.argChoices = values;
+    this.parseArg = (arg, previous) => {
+      if (!values.includes(arg)) {
+        throw new InvalidArgumentError(`Allowed choices are ${values.join(', ')}.`);
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  };
+
+  /**
+   * Make option-argument required.
+   */
+  argRequired() {
+    this.required = true;
+    return this;
+  }
+
+  /**
+   * Make option-argument optional.
+   */
+  argOptional() {
+    this.required = false;
+    return this;
+  }
+}
+
+/**
+ * Takes an argument and returns its human readable equivalent for help usage.
+ *
+ * @param {Argument} arg
+ * @return {string}
+ * @api private
+ */
+
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');
+
+  return arg.required
+    ? '<' + nameOutput + '>'
+    : '[' + nameOutput + ']';
+}
+
+exports.Argument = Argument;
+exports.humanReadableArgName = humanReadableArgName;

node_modules/html-minifier-terser/node_modules/commander/lib/error.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+/**
+ * CommanderError class
+ * @class
+ */
+class CommanderError extends Error {
+  /**
+   * Constructs the CommanderError class
+   * @param {number} exitCode suggested exit code which could be used with process.exit
+   * @param {string} code an id string representing the error
+   * @param {string} message human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode, code, message) {
+    super(message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.nestedError = undefined;
+  }
+}
+
+/**
+ * InvalidArgumentError class
+ * @class
+ */
+class InvalidArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidArgumentError class
+   * @param {string} [message] explanation of why argument is invalid
+   * @constructor
+   */
+  constructor(message) {
+    super(1, 'commander.invalidArgument', message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+  }
+}
+
+exports.CommanderError = CommanderError;
+exports.InvalidArgumentError = InvalidArgumentError;

node_modules/html-minifier-terser/node_modules/commander/lib/help.js

@@ -0,0 +1,396 @@
+const { humanReadableArgName } = require('./argument.js');
+
+/**
+ * TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`
+ * https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types
+ * @typedef { import("./argument.js").Argument } Argument
+ * @typedef { import("./command.js").Command } Command
+ * @typedef { import("./option.js").Option } Option
+ */
+
+// @ts-check
+
+// Although this is a class, methods are static in style to allow override using subclass or just functions.
+class Help {
+  constructor() {
+    this.helpWidth = undefined;
+    this.sortSubcommands = false;
+    this.sortOptions = false;
+  }
+
+  /**
+   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Command[]}
+   */
+
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter(cmd => !cmd._hidden);
+    if (cmd._hasImplicitHelpCommand()) {
+      // Create a command matching the implicit help command.
+      const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
+      const helpCommand = cmd.createCommand(helpName)
+        .helpOption(false);
+      helpCommand.description(cmd._helpCommandDescription);
+      if (helpArgs) helpCommand.arguments(helpArgs);
+      visibleCommands.push(helpCommand);
+    }
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        // @ts-ignore: overloaded return type
+        return a.name().localeCompare(b.name());
+      });
+    }
+    return visibleCommands;
+  }
+
+  /**
+   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
+
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    // Implicit help
+    const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
+    const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
+    if (showShortHelpFlag || showLongHelpFlag) {
+      let helpOption;
+      if (!showShortHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
+      } else if (!showLongHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
+      } else {
+        helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+      }
+      visibleOptions.push(helpOption);
+    }
+    if (this.sortOptions) {
+      const getSortKey = (option) => {
+        // WYSIWYG for order displayed in help with short before long, no special handling for negated.
+        return option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
+      };
+      visibleOptions.sort((a, b) => {
+        return getSortKey(a).localeCompare(getSortKey(b));
+      });
+    }
+    return visibleOptions;
+  }
+
+  /**
+   * Get an array of the arguments if any have a description.
+   *
+   * @param {Command} cmd
+   * @returns {Argument[]}
+   */
+
+  visibleArguments(cmd) {
+    // Side effect! Apply the legacy descriptions before the arguments are displayed.
+    if (cmd._argsDescription) {
+      cmd._args.forEach(argument => {
+        argument.description = argument.description || cmd._argsDescription[argument.name()] || '';
+      });
+    }
+
+    // If there are any arguments with a description then return all the arguments.
+    if (cmd._args.find(argument => argument.description)) {
+      return cmd._args;
+    };
+    return [];
+  }
+
+  /**
+   * Get the command term to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandTerm(cmd) {
+    // Legacy. Ignores custom usage string, and nested commands.
+    const args = cmd._args.map(arg => humanReadableArgName(arg)).join(' ');
+    return cmd._name +
+      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
+      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
+      (args ? ' ' + args : '');
+  }
+
+  /**
+   * Get the option term to show in the list of options.
+   *
+   * @param {Option} option
+   * @returns {string}
+   */
+
+  optionTerm(option) {
+    return option.flags;
+  }
+
+  /**
+   * Get the argument term to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @returns {string}
+   */
+
+  argumentTerm(argument) {
+    return argument.name();
+  }
+
+  /**
+   * Get the longest command term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(max, helper.subcommandTerm(command).length);
+    }, 0);
+  };
+
+  /**
+   * Get the longest option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(max, helper.optionTerm(option).length);
+    }, 0);
+  };
+
+  /**
+   * Get the longest argument term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(max, helper.argumentTerm(argument).length);
+    }, 0);
+  };
+
+  /**
+   * Get the command usage to be displayed at the top of the built-in help.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandUsage(cmd) {
+    // Usage
+    let cmdName = cmd._name;
+    if (cmd._aliases[0]) {
+      cmdName = cmdName + '|' + cmd._aliases[0];
+    }
+    let parentCmdNames = '';
+    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+      parentCmdNames = parentCmd.name() + ' ' + parentCmdNames;
+    }
+    return parentCmdNames + cmdName + ' ' + cmd.usage();
+  }
+
+  /**
+   * Get the description for the command.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.description();
+  }
+
+  /**
+   * Get the command description to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.description();
+  }
+
+  /**
+   * Get the option description to show in the list of options.
+   *
+   * @param {Option} option
+   * @return {string}
+   */
+
+  optionDescription(option) {
+    const extraInfo = [];
+    // Some of these do not make sense for negated boolean and suppress for backwards compatibility.
+
+    if (option.argChoices && !option.negate) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+    }
+    if (option.defaultValue !== undefined && !option.negate) {
+      extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+    }
+    if (option.envVar !== undefined) {
+      extraInfo.push(`env: ${option.envVar}`);
+    }
+    if (extraInfo.length > 0) {
+      return `${option.description} (${extraInfo.join(', ')})`;
+    }
+
+    return option.description;
+  };
+
+  /**
+   * Get the argument description to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @return {string}
+   */
+
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+    }
+    if (argument.defaultValue !== undefined) {
+      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescripton = `(${extraInfo.join(', ')})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescripton}`;
+      }
+      return extraDescripton;
+    }
+    return argument.description;
+  }
+
+  /**
+   * Generate the built-in help text.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {string}
+   */
+
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2; // between term and description
+    function formatItem(term, description) {
+      if (description) {
+        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+        return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+      }
+      return term;
+    };
+    function formatList(textArray) {
+      return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+    }
+
+    // Usage
+    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];
+
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([commandDescription, '']);
+    }
+
+    // Arguments
+    const argumentList = helper.visibleArguments(cmd).map((argument) => {
+      return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+    });
+    if (argumentList.length > 0) {
+      output = output.concat(['Arguments:', formatList(argumentList), '']);
+    }
+
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option) => {
+      return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+    });
+    if (optionList.length > 0) {
+      output = output.concat(['Options:', formatList(optionList), '']);
+    }
+
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((cmd) => {
+      return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
+    });
+    if (commandList.length > 0) {
+      output = output.concat(['Commands:', formatList(commandList), '']);
+    }
+
+    return output.join('\n');
+  }
+
+  /**
+   * Calculate the pad width from the maximum term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  padWidth(cmd, helper) {
+    return Math.max(
+      helper.longestOptionTermLength(cmd, helper),
+      helper.longestSubcommandTermLength(cmd, helper),
+      helper.longestArgumentTermLength(cmd, helper)
+    );
+  };
+
+  /**
+   * 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.
+   *
+   * @param {string} str
+   * @param {number} width
+   * @param {number} indent
+   * @param {number} [minColumnWidth=40]
+   * @return {string}
+   *
+   */
+
+  wrap(str, width, indent, minColumnWidth = 40) {
+    // Detect manually wrapped and indented strings by searching for line breaks
+    // followed by multiple spaces/tabs.
+    if (str.match(/[\n]\s+/)) return str;
+    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).
+    const columnWidth = width - indent;
+    if (columnWidth < minColumnWidth) return str;
+
+    const leadingStr = str.substr(0, indent);
+    const columnText = str.substr(indent);
+
+    const indentString = ' '.repeat(indent);
+    const regex = new RegExp('.{1,' + (columnWidth - 1) + '}([\\s\u200B]|$)|[^\\s\u200B]+?([\\s\u200B]|$)', 'g');
+    const lines = columnText.match(regex) || [];
+    return leadingStr + lines.map((line, i) => {
+      if (line.slice(-1) === '\n') {
+        line = line.slice(0, line.length - 1);
+      }
+      return ((i > 0) ? indentString : '') + line.trimRight();
+    }).join('\n');
+  }
+}
+
+exports.Help = Help;

node_modules/html-minifier-terser/node_modules/commander/lib/option.js

@@ -0,0 +1,208 @@
+const { InvalidArgumentError } = require('./error.js');
+
+// @ts-check
+
+class Option {
+  /**
+   * Initialize a new `Option` with the given `flags` and `description`.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   */
+
+  constructor(flags, description) {
+    this.flags = flags;
+    this.description = description || '';
+
+    this.required = flags.includes('<'); // A value must be supplied when the option is specified.
+    this.optional = flags.includes('['); // A value is optional when the option is specified.
+    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags); // The option can take multiple values.
+    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.
+    const optionFlags = splitOptionFlags(flags);
+    this.short = optionFlags.shortFlag;
+    this.long = optionFlags.longFlag;
+    this.negate = false;
+    if (this.long) {
+      this.negate = this.long.startsWith('--no-');
+    }
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.envVar = undefined;
+    this.parseArg = undefined;
+    this.hidden = false;
+    this.argChoices = undefined;
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {any} value
+   * @param {string} [description]
+   * @return {Option}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  };
+
+  /**
+   * Set environment variable to check for option value.
+   * Priority order of option values is default < env < cli
+   *
+   * @param {string} name
+   * @return {Option}
+   */
+
+  env(name) {
+    this.envVar = name;
+    return this;
+  };
+
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   *
+   * @param {Function} [fn]
+   * @return {Option}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  };
+
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   *
+   * @param {boolean} [mandatory=true]
+   * @return {Option}
+   */
+
+  makeOptionMandatory(mandatory = true) {
+    this.mandatory = !!mandatory;
+    return this;
+  };
+
+  /**
+   * Hide option in help.
+   *
+   * @param {boolean} [hide=true]
+   * @return {Option}
+   */
+
+  hideHelp(hide = true) {
+    this.hidden = !!hide;
+    return this;
+  };
+
+  /**
+   * @api private
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Only allow option value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Option}
+   */
+
+  choices(values) {
+    this.argChoices = values;
+    this.parseArg = (arg, previous) => {
+      if (!values.includes(arg)) {
+        throw new InvalidArgumentError(`Allowed choices are ${values.join(', ')}.`);
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  };
+
+  /**
+   * Return option name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    if (this.long) {
+      return this.long.replace(/^--/, '');
+    }
+    return this.short.replace(/^-/, '');
+  };
+
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as a object attribute key.
+   *
+   * @return {string}
+   * @api private
+   */
+
+  attributeName() {
+    return camelcase(this.name().replace(/^no-/, ''));
+  };
+
+  /**
+   * Check if `arg` matches the short or long flag.
+   *
+   * @param {string} arg
+   * @return {boolean}
+   * @api private
+   */
+
+  is(arg) {
+    return this.short === arg || this.long === arg;
+  };
+}
+
+/**
+ * Convert string from kebab-case to camelCase.
+ *
+ * @param {string} str
+ * @return {string}
+ * @api private
+ */
+
+function camelcase(str) {
+  return str.split('-').reduce((str, word) => {
+    return str + word[0].toUpperCase() + word.slice(1);
+  });
+}
+
+/**
+ * Split the short and long flag out of something like '-m,--mixed <value>'
+ *
+ * @api private
+ */
+
+function splitOptionFlags(flags) {
+  let shortFlag;
+  let longFlag;
+  // Use original very loose parsing to maintain backwards compatibility for now,
+  // which allowed for example unintended `-sw, --short-word` [sic].
+  const flagParts = flags.split(/[ |,]+/);
+  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1])) shortFlag = flagParts.shift();
+  longFlag = flagParts.shift();
+  // Add support for lone short flag without significantly changing parsing!
+  if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    shortFlag = longFlag;
+    longFlag = undefined;
+  }
+  return { shortFlag, longFlag };
+}
+
+exports.Option = Option;
+exports.splitOptionFlags = splitOptionFlags;

node_modules/html-minifier-terser/node_modules/commander/lib/suggestSimilar.js

@@ -0,0 +1,100 @@
+const maxDistance = 3;
+
+function editDistance(a, b) {
+  // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
+  // Calculating optimal string alignment distance, no substring is edited more than once.
+  // (Simple implementation.)
+
+  // Quick early exit, return worst case.
+  if (Math.abs(a.length - b.length) > maxDistance) return Math.max(a.length, b.length);
+
+  // distance between prefix substrings of a and b
+  const d = [];
+
+  // pure deletions turn a into empty string
+  for (let i = 0; i <= a.length; i++) {
+    d[i] = [i];
+  }
+  // pure insertions turn empty string into b
+  for (let j = 0; j <= b.length; j++) {
+    d[0][j] = j;
+  }
+
+  // fill matrix
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      let cost = 1;
+      if (a[i - 1] === b[j - 1]) {
+        cost = 0;
+      } else {
+        cost = 1;
+      }
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1, // deletion
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j - 1] + cost // substitution
+      );
+      // transposition
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+
+  return d[a.length][b.length];
+}
+
+/**
+ * Find close matches, restricted to same number of edits.
+ *
+ * @param {string} word
+ * @param {string[]} candidates
+ * @returns {string}
+ */
+
+function suggestSimilar(word, candidates) {
+  if (!candidates || candidates.length === 0) return '';
+  // remove possible duplicates
+  candidates = Array.from(new Set(candidates));
+
+  const searchingOptions = word.startsWith('--');
+  if (searchingOptions) {
+    word = word.slice(2);
+    candidates = candidates.map(candidate => candidate.slice(2));
+  }
+
+  let similar = [];
+  let bestDistance = maxDistance;
+  const minSimilarity = 0.4;
+  candidates.forEach((candidate) => {
+    if (candidate.length <= 1) return; // no one character guesses
+
+    const distance = editDistance(word, candidate);
+    const length = Math.max(word.length, candidate.length);
+    const similarity = (length - distance) / length;
+    if (similarity > minSimilarity) {
+      if (distance < bestDistance) {
+        // better edit distance, throw away previous worse matches
+        bestDistance = distance;
+        similar = [candidate];
+      } else if (distance === bestDistance) {
+        similar.push(candidate);
+      }
+    }
+  });
+
+  similar.sort((a, b) => a.localeCompare(b));
+  if (searchingOptions) {
+    similar = similar.map(candidate => `--${candidate}`);
+  }
+
+  if (similar.length > 1) {
+    return `\n(Did you mean one of ${similar.join(', ')}?)`;
+  }
+  if (similar.length === 1) {
+    return `\n(Did you mean ${similar[0]}?)`;
+  }
+  return '';
+}
+
+exports.suggestSimilar = suggestSimilar;

node_modules/html-minifier-terser/node_modules/commander/package-support.json

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

node_modules/html-minifier-terser/node_modules/commander/package.json

@@ -0,0 +1,101 @@
+{
+  "_from": "commander@^8.3.0",
+  "_id": "commander@8.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
+  "_location": "/html-minifier-terser/commander",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "commander@^8.3.0",
+    "name": "commander",
+    "escapedName": "commander",
+    "rawSpec": "^8.3.0",
+    "saveSpec": null,
+    "fetchSpec": "^8.3.0"
+  },
+  "_requiredBy": [
+    "/html-minifier-terser"
+  ],
+  "_resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
+  "_shasum": "4837ea1b2da67b9c616a67afbb0fafee567bca66",
+  "_spec": "commander@^8.3.0",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app\\node_modules\\html-minifier-terser",
+  "author": {
+    "name": "TJ Holowaychuk",
+    "email": "tj@vision-media.ca"
+  },
+  "bugs": {
+    "url": "https://github.com/tj/commander.js/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "the complete solution for node.js command-line programs",
+  "devDependencies": {
+    "@types/jest": "^26.0.23",
+    "@types/node": "^14.17.3",
+    "@typescript-eslint/eslint-plugin": "^4.27.0",
+    "@typescript-eslint/parser": "^4.27.0",
+    "eslint": "^7.29.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-jest": "^24.3.6",
+    "jest": "^27.0.4",
+    "standard": "^16.0.3",
+    "ts-jest": "^27.0.3",
+    "tsd": "^0.17.0",
+    "typescript": "^4.3.4"
+  },
+  "engines": {
+    "node": ">= 12"
+  },
+  "files": [
+    "index.js",
+    "lib/*.js",
+    "esm.mjs",
+    "typings/index.d.ts",
+    "package-support.json"
+  ],
+  "homepage": "https://github.com/tj/commander.js#readme",
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverage": true,
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ]
+  },
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser",
+    "cli",
+    "argument",
+    "args",
+    "argv"
+  ],
+  "license": "MIT",
+  "main": "./index.js",
+  "name": "commander",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "lint": "eslint index.js esm.mjs \"lib/*.js\" \"tests/**/*.js\"",
+    "test": "jest && npm run test-typings",
+    "test-all": "npm run test && npm run lint && npm run typescript-lint && npm run typescript-checkJS && npm run test-esm",
+    "test-esm": "node --experimental-modules ./tests/esm-imports-test.mjs",
+    "test-typings": "tsd",
+    "typescript-checkJS": "tsc --allowJS --checkJS index.js lib/*.js --noEmit",
+    "typescript-lint": "eslint typings/*.ts tests/*.ts"
+  },
+  "support": true,
+  "type": "commonjs",
+  "types": "typings/index.d.ts",
+  "version": "8.3.0"
+}

node_modules/html-minifier-terser/node_modules/commander/typings/index.d.ts

@@ -0,0 +1,774 @@
+// 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 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: string[]): this;
+
+  /**
+   * Make option-argument required.
+   */
+  argRequired(): this;
+
+  /**
+   * Make option-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.
+  optionFlags: string;
+  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;
+
+  /**
+   * Set environment variable to check for option value.
+   * Priority order of option values is default < env < cli
+   */
+  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: 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;
+}
+
+export class Help {
+  /** output helpWidth, long lines are wrapped to fit */
+  helpWidth?: number;
+  sortSubcommands: boolean;
+  sortOptions: boolean;
+
+  constructor();
+
+  /** Get the command term to show in the list of subcommands. */
+  subcommandTerm(cmd: Command): string;
+  /** Get the command description 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 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 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 = 'preAction' | 'postAction';
+export type OptionValueSource = 'default' | 'env' | 'config' | 'cli';
+
+export interface OptionValues {
+  [key: string]: any;
+}
+
+export class Command {
+  args: string[];
+  processedArgs: any[];
+  commands: Command[];
+  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;
+
+  /**
+   * 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): 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): 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): 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): 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;
+
+  /**
+   * Retrieve option value source.
+   */
+  getOptionValueSource(key: string): OptionValueSource;
+
+   /**
+   * 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?: 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?: 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 options as key-value pairs
+   */
+  opts<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: {[argName: string]: string}): this;
+  /**
+   * Get the description.
+   */
+  description(): 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: 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;
+
+  /**
+   * 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;

node_modules/html-minifier-terser/package.json

@@ -0,0 +1,143 @@
+{
+  "_from": "html-minifier-terser@^6.0.2",
+  "_id": "html-minifier-terser@6.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==",
+  "_location": "/html-minifier-terser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "html-minifier-terser@^6.0.2",
+    "name": "html-minifier-terser",
+    "escapedName": "html-minifier-terser",
+    "rawSpec": "^6.0.2",
+    "saveSpec": null,
+    "fetchSpec": "^6.0.2"
+  },
+  "_requiredBy": [
+    "/html-webpack-plugin"
+  ],
+  "_resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
+  "_shasum": "bfc818934cc07918f6b3669f5774ecdfd48f32ab",
+  "_spec": "html-minifier-terser@^6.0.2",
+  "_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app\\node_modules\\html-webpack-plugin",
+  "author": {
+    "name": "Daniel Ruf"
+  },
+  "benchmarkDependencies": {
+    "chalk": "^2.4.2",
+    "cli-table3": "^0.5.1",
+    "iltorb": "^2.4.4",
+    "lzma": "^2.3.2",
+    "minimize": "^2.2.0",
+    "progress": "^2.0.3"
+  },
+  "bin": {
+    "html-minifier-terser": "cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/terser/html-minifier-terser/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Gilmore Davidson",
+      "url": "https://github.com/gilmoreorless"
+    },
+    {
+      "name": "Hugo Wetterberg",
+      "email": "hugo@wetterberg.nu"
+    },
+    {
+      "name": "Zoltan Frombach",
+      "email": "tssajo@gmail.com"
+    }
+  ],
+  "dependencies": {
+    "camel-case": "^4.1.2",
+    "clean-css": "^5.2.2",
+    "commander": "^8.3.0",
+    "he": "^1.2.0",
+    "param-case": "^3.0.4",
+    "relateurl": "^0.2.7",
+    "terser": "^5.10.0"
+  },
+  "deprecated": false,
+  "description": "Highly configurable, well-tested, JavaScript-based HTML minifier.",
+  "devDependencies": {
+    "grunt": "^1.4.1",
+    "grunt-browserify": "^6.0.0",
+    "grunt-eslint": "^24.0.0",
+    "grunt-terser": "^2.0.0",
+    "husky": "^7.0.4",
+    "is-ci": "^3.0.1",
+    "lint-staged": "^12.1.2",
+    "node-qunit-puppeteer": "^2.1.0",
+    "qunit": "2.16.0",
+    "serve": "^13.0.2"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "files": [
+    "src/*.js",
+    "cli.js",
+    "sample-cli-config-file.conf"
+  ],
+  "homepage": "https://terser.org/html-minifier-terser/",
+  "keywords": [
+    "cli",
+    "compress",
+    "compressor",
+    "css",
+    "html",
+    "htmlmin",
+    "javascript",
+    "min",
+    "minification",
+    "minifier",
+    "minify",
+    "optimize",
+    "optimizer",
+    "pack",
+    "packer",
+    "parse",
+    "parser",
+    "terser",
+    "uglifier",
+    "uglify"
+  ],
+  "license": "MIT",
+  "main": "src/htmlminifier.js",
+  "maintainers": [
+    {
+      "name": "Daniel Ruf"
+    },
+    {
+      "name": "Alex Lam",
+      "email": "alexlamsl@gmail.com"
+    },
+    {
+      "name": "Juriy Zaytsev",
+      "email": "kangax@gmail.com",
+      "url": "http://perfectionkills.com/"
+    },
+    {
+      "name": "Sibiraj",
+      "email": "sibiraj.dev"
+    }
+  ],
+  "name": "html-minifier-terser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/terser/html-minifier-terser.git"
+  },
+  "scripts": {
+    "dist": "grunt dist",
+    "prepare": "is-ci || husky install",
+    "serve": "npm run dist && serve . -p 6753",
+    "test": "grunt test"
+  },
+  "version": "6.1.0"
+}

node_modules/html-minifier-terser/sample-cli-config-file.conf

@@ -0,0 +1,40 @@
+{
+  "caseSensitive": false,
+  "collapseBooleanAttributes": true,
+  "collapseInlineTagWhitespace": false,
+  "collapseWhitespace": true,
+  "conservativeCollapse": false,
+  "continueOnParseError": true,
+  "customAttrCollapse": ".*",
+  "decodeEntities": true,
+  "html5": true,
+  "ignoreCustomFragments": [
+    "<#[\\s\\S]*?#>",
+    "<%[\\s\\S]*?%>",
+    "<\\?[\\s\\S]*?\\?>"
+  ],
+  "includeAutoGeneratedTags": false,
+  "keepClosingSlash": false,
+  "maxLineLength": 0,
+  "minifyCSS": true,
+  "minifyJS": true,
+  "preserveLineBreaks": false,
+  "preventAttributesEscaping": false,
+  "processConditionalComments": true,
+  "processScripts": [
+    "text/html"
+  ],
+  "removeAttributeQuotes": true,
+  "removeComments": true,
+  "removeEmptyAttributes": true,
+  "removeEmptyElements": true,
+  "removeOptionalTags": true,
+  "removeRedundantAttributes": true,
+  "removeScriptTypeAttributes": true,
+  "removeStyleLinkTypeAttributes": true,
+  "removeTagWhitespace": true,
+  "sortAttributes": true,
+  "sortClassName": true,
+  "trimCustomFragments": true,
+  "useShortDoctype": true
+}

node_modules/html-minifier-terser/src/htmlparser.js

@@ -0,0 +1,581 @@
+/*!
+ * HTML Parser By John Resig (ejohn.org)
+ * Modified by Juriy "kangax" Zaytsev
+ * Original code by Erik Arvidsson, Mozilla Public License
+ * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
+ */
+
+/*
+ * // Use like so:
+ * HTMLParser(htmlString, {
+ *     start: function(tag, attrs, unary) {},
+ *     end: function(tag) {},
+ *     chars: function(text) {},
+ *     comment: function(text) {}
+ * });
+ *
+ * // or to get an XML string:
+ * HTMLtoXML(htmlString);
+ *
+ * // or to get an XML DOM Document
+ * HTMLtoDOM(htmlString);
+ *
+ * // or to inject into an existing document/DOM node
+ * HTMLtoDOM(htmlString, document);
+ * HTMLtoDOM(htmlString, document.body);
+ *
+ */
+
+/* global ActiveXObject, DOMDocument */
+
+'use strict';
+
+var createMapFromString = require('./utils').createMapFromString;
+var replaceAsync = require('./utils').replaceAsync;
+
+function makeMap(values) {
+  return createMapFromString(values, true);
+}
+
+// Regular Expressions for parsing tags and attributes
+var singleAttrIdentifier = /([^\s"'<>/=]+)/,
+    singleAttrAssigns = [/=/],
+    singleAttrValues = [
+    // attr value double quotes
+      /"([^"]*)"+/.source,
+      // attr value, single quotes
+      /'([^']*)'+/.source,
+      // attr value, no quotes
+      /([^ \t\n\f\r"'`=<>]+)/.source
+    ],
+    // https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
+    qnameCapture = (function() {
+    // based on https://www.npmjs.com/package/ncname
+      var combiningChar = '\\u0300-\\u0345\\u0360\\u0361\\u0483-\\u0486\\u0591-\\u05A1\\u05A3-\\u05B9\\u05BB-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u064B-\\u0652\\u0670\\u06D6-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0901-\\u0903\\u093C\\u093E-\\u094D\\u0951-\\u0954\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A02\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A70\\u0A71\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B43\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B82\\u0B83\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C01-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C82\\u0C83\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86-\\u0F8B\\u0F90-\\u0F95\\u0F97\\u0F99-\\u0FAD\\u0FB1-\\u0FB7\\u0FB9\\u20D0-\\u20DC\\u20E1\\u302A-\\u302F\\u3099\\u309A';
+      var digit = '0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE7-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29';
+      var extender = '\\xB7\\u02D0\\u02D1\\u0387\\u0640\\u0E46\\u0EC6\\u3005\\u3031-\\u3035\\u309D\\u309E\\u30FC-\\u30FE';
+      var letter = 'A-Za-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u0131\\u0134-\\u013E\\u0141-\\u0148\\u014A-\\u017E\\u0180-\\u01C3\\u01CD-\\u01F0\\u01F4\\u01F5\\u01FA-\\u0217\\u0250-\\u02A8\\u02BB-\\u02C1\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03D0-\\u03D6\\u03DA\\u03DC\\u03DE\\u03E0\\u03E2-\\u03F3\\u0401-\\u040C\\u040E-\\u044F\\u0451-\\u045C\\u045E-\\u0481\\u0490-\\u04C4\\u04C7\\u04C8\\u04CB\\u04CC\\u04D0-\\u04EB\\u04EE-\\u04F5\\u04F8\\u04F9\\u0531-\\u0556\\u0559\\u0561-\\u0586\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u063A\\u0641-\\u064A\\u0671-\\u06B7\\u06BA-\\u06BE\\u06C0-\\u06CE\\u06D0-\\u06D3\\u06D5\\u06E5\\u06E6\\u0905-\\u0939\\u093D\\u0958-\\u0961\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8B\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AE0\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B36-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB5\\u0BB7-\\u0BB9\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D60\\u0D61\\u0E01-\\u0E2E\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E45\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD\\u0EAE\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0F40-\\u0F47\\u0F49-\\u0F69\\u10A0-\\u10C5\\u10D0-\\u10F6\\u1100\\u1102\\u1103\\u1105-\\u1107\\u1109\\u110B\\u110C\\u110E-\\u1112\\u113C\\u113E\\u1140\\u114C\\u114E\\u1150\\u1154\\u1155\\u1159\\u115F-\\u1161\\u1163\\u1165\\u1167\\u1169\\u116D\\u116E\\u1172\\u1173\\u1175\\u119E\\u11A8\\u11AB\\u11AE\\u11AF\\u11B7\\u11B8\\u11BA\\u11BC-\\u11C2\\u11EB\\u11F0\\u11F9\\u1E00-\\u1E9B\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2126\\u212A\\u212B\\u212E\\u2180-\\u2182\\u3007\\u3021-\\u3029\\u3041-\\u3094\\u30A1-\\u30FA\\u3105-\\u312C\\u4E00-\\u9FA5\\uAC00-\\uD7A3';
+      var ncname = '[' + letter + '_][' + letter + digit + '\\.\\-_' + combiningChar + extender + ']*';
+      return '((?:' + ncname + '\\:)?' + ncname + ')';
+    })(),
+    startTagOpen = new RegExp('^<' + qnameCapture),
+    startTagClose = /^\s*(\/?)>/,
+    endTag = new RegExp('^<\\/' + qnameCapture + '[^>]*>'),
+    doctype = /^<!DOCTYPE\s?[^>]+>/i;
+
+var IS_REGEX_CAPTURING_BROKEN = false;
+'x'.replace(/x(.)?/g, function(m, g) {
+  IS_REGEX_CAPTURING_BROKEN = g === '';
+});
+
+// Empty Elements
+var empty = makeMap('area,base,basefont,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr');
+
+// Inline Elements
+var inline = makeMap('a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,noscript,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,svg,textarea,tt,u,var');
+
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var closeSelf = makeMap('colgroup,dd,dt,li,option,p,td,tfoot,th,thead,tr,source');
+
+// Attributes that have their values filled in disabled='disabled'
+var fillAttrs = makeMap('checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected');
+
+// Special Elements (can contain anything)
+var special = makeMap('script,style');
+
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+var nonPhrasing = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,ol,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track,ul');
+
+var reCache = {};
+
+function attrForHandler(handler) {
+  var pattern = singleAttrIdentifier.source +
+    '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
+    '[ \\t\\n\\f\\r]*(?:' + singleAttrValues.join('|') + '))?';
+  if (handler.customAttrSurround) {
+    var attrClauses = [];
+    for (var i = handler.customAttrSurround.length - 1; i >= 0; i--) {
+      attrClauses[i] = '(?:' +
+        '(' + handler.customAttrSurround[i][0].source + ')\\s*' +
+        pattern +
+        '\\s*(' + handler.customAttrSurround[i][1].source + ')' +
+        ')';
+    }
+    attrClauses.push('(?:' + pattern + ')');
+    pattern = '(?:' + attrClauses.join('|') + ')';
+  }
+  return new RegExp('^\\s*' + pattern);
+}
+
+function joinSingleAttrAssigns(handler) {
+  return singleAttrAssigns.concat(
+    handler.customAttrAssign || []
+  ).map(function(assign) {
+    return '(?:' + assign.source + ')';
+  }).join('|');
+}
+
+class HTMLParser {
+  constructor(html, handler) {
+    this.html = html;
+    this.handler = handler;
+  }
+
+  async parse() {
+    let html = this.html;
+    const handler = this.handler;
+
+    var stack = [], lastTag;
+    var attribute = attrForHandler(handler);
+    var last, prevTag, nextTag;
+    while (html) {
+      last = html;
+      // Make sure we're not in a script or style element
+      if (!lastTag || !special(lastTag)) {
+        var textEnd = html.indexOf('<');
+        if (textEnd === 0) {
+          // Comment:
+          if (/^<!--/.test(html)) {
+            var commentEnd = html.indexOf('-->');
+
+            if (commentEnd >= 0) {
+              if (handler.comment) {
+                await handler.comment(html.substring(4, commentEnd));
+              }
+              html = html.substring(commentEnd + 3);
+              prevTag = '';
+              continue;
+            }
+          }
+
+          // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+          if (/^<!\[/.test(html)) {
+            var conditionalEnd = html.indexOf(']>');
+
+            if (conditionalEnd >= 0) {
+              if (handler.comment) {
+                await handler.comment(html.substring(2, conditionalEnd + 1), true /* non-standard */);
+              }
+              html = html.substring(conditionalEnd + 2);
+              prevTag = '';
+              continue;
+            }
+          }
+
+          // Doctype:
+          var doctypeMatch = html.match(doctype);
+          if (doctypeMatch) {
+            if (handler.doctype) {
+              handler.doctype(doctypeMatch[0]);
+            }
+            html = html.substring(doctypeMatch[0].length);
+            prevTag = '';
+            continue;
+          }
+
+          // End tag:
+          var endTagMatch = html.match(endTag);
+          if (endTagMatch) {
+            html = html.substring(endTagMatch[0].length);
+            await replaceAsync(endTagMatch[0], endTag, parseEndTag);
+            prevTag = '/' + endTagMatch[1].toLowerCase();
+            continue;
+          }
+
+          // Start tag:
+          var startTagMatch = parseStartTag(html);
+          if (startTagMatch) {
+            html = startTagMatch.rest;
+            await handleStartTag(startTagMatch);
+            prevTag = startTagMatch.tagName.toLowerCase();
+            continue;
+          }
+
+          // Treat `<` as text
+          if (handler.continueOnParseError) {
+            textEnd = html.indexOf('<', 1);
+          }
+        }
+
+        var text;
+        if (textEnd >= 0) {
+          text = html.substring(0, textEnd);
+          html = html.substring(textEnd);
+        }
+        else {
+          text = html;
+          html = '';
+        }
+
+        // next tag
+        var nextTagMatch = parseStartTag(html);
+        if (nextTagMatch) {
+          nextTag = nextTagMatch.tagName;
+        }
+        else {
+          nextTagMatch = html.match(endTag);
+          if (nextTagMatch) {
+            nextTag = '/' + nextTagMatch[1];
+          }
+          else {
+            nextTag = '';
+          }
+        }
+
+        if (handler.chars) {
+          await handler.chars(text, prevTag, nextTag);
+        }
+        prevTag = '';
+      }
+      else {
+        var stackedTag = lastTag.toLowerCase();
+        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)</' + stackedTag + '[^>]*>', 'i'));
+
+        html = await replaceAsync(html, reStackedTag, async(_, text) => {
+          if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
+            text = text
+              .replace(/<!--([\s\S]*?)-->/g, '$1')
+              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+          }
+
+
+          if (handler.chars) {
+            await handler.chars(text);
+          }
+
+          return '';
+        });
+
+        await parseEndTag('</' + stackedTag + '>', stackedTag);
+      }
+
+      if (html === last) {
+        throw new Error('Parse Error: ' + html);
+      }
+    }
+
+    if (!handler.partialMarkup) {
+      // Clean up any remaining tags
+      await parseEndTag();
+    }
+
+    function parseStartTag(input) {
+      var start = input.match(startTagOpen);
+      if (start) {
+        var match = {
+          tagName: start[1],
+          attrs: []
+        };
+        input = input.slice(start[0].length);
+        var end, attr;
+        while (!(end = input.match(startTagClose)) && (attr = input.match(attribute))) {
+          input = input.slice(attr[0].length);
+          match.attrs.push(attr);
+        }
+        if (end) {
+          match.unarySlash = end[1];
+          match.rest = input.slice(end[0].length);
+          return match;
+        }
+      }
+    }
+
+    async function closeIfFound(tagName) {
+      if (findTag(tagName) >= 0) {
+        await parseEndTag('', tagName);
+        return true;
+      }
+    }
+
+    async function handleStartTag(match) {
+      var tagName = match.tagName;
+      var unarySlash = match.unarySlash;
+
+      if (handler.html5) {
+        if (lastTag === 'p' && nonPhrasing(tagName)) {
+          await parseEndTag('', lastTag);
+        }
+        else if (tagName === 'tbody') {
+          await closeIfFound('thead');
+        }
+        else if (tagName === 'tfoot') {
+          if (!await closeIfFound('tbody')) {
+            await closeIfFound('thead');
+          }
+        }
+        if (tagName === 'col' && findTag('colgroup') < 0) {
+          lastTag = 'colgroup';
+          stack.push({ tag: lastTag, attrs: [] });
+          if (handler.start) {
+            await handler.start(lastTag, [], false, '');
+          }
+        }
+      }
+
+      if (!handler.html5 && !inline(tagName)) {
+        while (lastTag && inline(lastTag)) {
+          await parseEndTag('', lastTag);
+        }
+      }
+
+      if (closeSelf(tagName) && lastTag === tagName) {
+        await parseEndTag('', tagName);
+      }
+
+      var unary = empty(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;
+
+      var attrs = match.attrs.map(function(args) {
+        var name, value, customOpen, customClose, customAssign, quote;
+        var ncp = 7; // number of captured parts, scalar
+
+        // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
+        if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
+          if (args[3] === '') { delete args[3]; }
+          if (args[4] === '') { delete args[4]; }
+          if (args[5] === '') { delete args[5]; }
+        }
+
+        function populate(index) {
+          customAssign = args[index];
+          value = args[index + 1];
+          if (typeof value !== 'undefined') {
+            return '"';
+          }
+          value = args[index + 2];
+          if (typeof value !== 'undefined') {
+            return '\'';
+          }
+          value = args[index + 3];
+          if (typeof value === 'undefined' && fillAttrs(name)) {
+            value = name;
+          }
+          return '';
+        }
+
+        var j = 1;
+        if (handler.customAttrSurround) {
+          for (var i = 0, l = handler.customAttrSurround.length; i < l; i++, j += ncp) {
+            name = args[j + 1];
+            if (name) {
+              quote = populate(j + 2);
+              customOpen = args[j];
+              customClose = args[j + 6];
+              break;
+            }
+          }
+        }
+
+        if (!name && (name = args[j])) {
+          quote = populate(j + 1);
+        }
+
+        return {
+          name: name,
+          value: value,
+          customAssign: customAssign || '=',
+          customOpen: customOpen || '',
+          customClose: customClose || '',
+          quote: quote || ''
+        };
+      });
+
+      if (!unary) {
+        stack.push({ tag: tagName, attrs: attrs });
+        lastTag = tagName;
+        unarySlash = '';
+      }
+
+      if (handler.start) {
+        await handler.start(tagName, attrs, unary, unarySlash);
+      }
+    }
+
+    function findTag(tagName) {
+      var pos;
+      var needle = tagName.toLowerCase();
+      for (pos = stack.length - 1; pos >= 0; pos--) {
+        if (stack[pos].tag.toLowerCase() === needle) {
+          break;
+        }
+      }
+      return pos;
+    }
+
+    async function parseEndTag(tag, tagName) {
+      var pos;
+
+      // Find the closest opened tag of the same type
+      if (tagName) {
+        pos = findTag(tagName);
+      }
+      // If no tag name is provided, clean shop
+      else {
+        pos = 0;
+      }
+
+      if (pos >= 0) {
+        // Close all the open elements, up the stack
+        for (var i = stack.length - 1; i >= pos; i--) {
+          if (handler.end) {
+            handler.end(stack[i].tag, stack[i].attrs, i > pos || !tag);
+          }
+        }
+
+        // Remove the open elements from the stack
+        stack.length = pos;
+        lastTag = pos && stack[pos - 1].tag;
+      }
+      else if (tagName.toLowerCase() === 'br') {
+        if (handler.start) {
+          await handler.start(tagName, [], true, '');
+        }
+      }
+      else if (tagName.toLowerCase() === 'p') {
+        if (handler.start) {
+          await handler.start(tagName, [], false, '', true);
+        }
+        if (handler.end) {
+          handler.end(tagName, []);
+        }
+      }
+    }
+  }
+}
+
+exports.HTMLParser = HTMLParser;
+exports.HTMLtoXML = function(html) {
+  var results = '';
+
+  new HTMLParser(html, {
+    start: function(tag, attrs, unary) {
+      results += '<' + tag;
+
+      for (var i = 0, len = attrs.length; i < len; i++) {
+        results += ' ' + attrs[i].name + '="' + (attrs[i].value || '').replace(/"/g, '&#34;') + '"';
+      }
+
+      results += (unary ? '/' : '') + '>';
+    },
+    end: function(tag) {
+      results += '</' + tag + '>';
+    },
+    chars: function(text) {
+      results += text;
+    },
+    comment: function(text) {
+      results += '<!--' + text + '-->';
+    },
+    ignore: function(text) {
+      results += text;
+    }
+  });
+
+  return results;
+};
+
+exports.HTMLtoDOM = function(html, doc) {
+  // There can be only one of these elements
+  var one = {
+    html: true,
+    head: true,
+    body: true,
+    title: true
+  };
+
+  // Enforce a structure for the document
+  var structure = {
+    link: 'head',
+    base: 'head'
+  };
+
+  if (doc) {
+    doc = doc.ownerDocument || doc.getOwnerDocument && doc.getOwnerDocument() || doc;
+  }
+  else if (typeof DOMDocument !== 'undefined') {
+    doc = new DOMDocument();
+  }
+  else if (typeof document !== 'undefined' && document.implementation && document.implementation.createDocument) {
+    doc = document.implementation.createDocument('', '', null);
+  }
+  else if (typeof ActiveX !== 'undefined') {
+    doc = new ActiveXObject('Msxml.DOMDocument');
+  }
+
+  var elems = [],
+      documentElement = doc.documentElement ||
+      doc.getDocumentElement && doc.getDocumentElement();
+
+  // If we're dealing with an empty document then we
+  // need to pre-populate it with the HTML document structure
+  if (!documentElement && doc.createElement) {
+    (function() {
+      var html = doc.createElement('html');
+      var head = doc.createElement('head');
+      head.appendChild(doc.createElement('title'));
+      html.appendChild(head);
+      html.appendChild(doc.createElement('body'));
+      doc.appendChild(html);
+    })();
+  }
+
+  // Find all the unique elements
+  if (doc.getElementsByTagName) {
+    for (var i in one) {
+      one[i] = doc.getElementsByTagName(i)[0];
+    }
+  }
+
+  // If we're working with a document, inject contents into
+  // the body element
+  var curParentNode = one.body;
+
+  new HTMLParser(html, {
+    start: function(tagName, attrs, unary) {
+      // If it's a pre-built element, then we can ignore
+      // its construction
+      if (one[tagName]) {
+        curParentNode = one[tagName];
+        return;
+      }
+
+      var elem = doc.createElement(tagName);
+
+      for (var attr in attrs) {
+        elem.setAttribute(attrs[attr].name, attrs[attr].value);
+      }
+
+      if (structure[tagName] && typeof one[structure[tagName]] !== 'boolean') {
+        one[structure[tagName]].appendChild(elem);
+      }
+      else if (curParentNode && curParentNode.appendChild) {
+        curParentNode.appendChild(elem);
+      }
+
+      if (!unary) {
+        elems.push(elem);
+        curParentNode = elem;
+      }
+    },
+    end: function(/* tag */) {
+      elems.length -= 1;
+
+      // Init the new parentNode
+      curParentNode = elems[elems.length - 1];
+    },
+    chars: function(text) {
+      curParentNode.appendChild(doc.createTextNode(text));
+    },
+    comment: function(/* text */) {
+      // create comment node
+    },
+    ignore: function(/* text */) {
+      // What to do here?
+    }
+  });
+
+  return doc;
+};
+
+exports.endTag = endTag;

node_modules/html-minifier-terser/src/tokenchain.js

@@ -0,0 +1,71 @@
+'use strict';
+
+function Sorter() {
+}
+
+Sorter.prototype.sort = function(tokens, fromIndex) {
+  fromIndex = fromIndex || 0;
+  for (var i = 0, len = this.keys.length; i < len; i++) {
+    var key = this.keys[i];
+    var token = key.slice(1);
+    var index = tokens.indexOf(token, fromIndex);
+    if (index !== -1) {
+      do {
+        if (index !== fromIndex) {
+          tokens.splice(index, 1);
+          tokens.splice(fromIndex, 0, token);
+        }
+        fromIndex++;
+      } while ((index = tokens.indexOf(token, fromIndex)) !== -1);
+      return this[key].sort(tokens, fromIndex);
+    }
+  }
+  return tokens;
+};
+
+function TokenChain() {
+}
+
+TokenChain.prototype = {
+  add: function(tokens) {
+    var self = this;
+    tokens.forEach(function(token) {
+      var key = '$' + token;
+      if (!self[key]) {
+        self[key] = [];
+        self[key].processed = 0;
+      }
+      self[key].push(tokens);
+    });
+  },
+  createSorter: function() {
+    var self = this;
+    var sorter = new Sorter();
+    sorter.keys = Object.keys(self).sort(function(j, k) {
+      var m = self[j].length;
+      var n = self[k].length;
+      return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0;
+    }).filter(function(key) {
+      if (self[key].processed < self[key].length) {
+        var token = key.slice(1);
+        var chain = new TokenChain();
+        self[key].forEach(function(tokens) {
+          var index;
+          while ((index = tokens.indexOf(token)) !== -1) {
+            tokens.splice(index, 1);
+          }
+          tokens.forEach(function(token) {
+            self['$' + token].processed++;
+          });
+          chain.add(tokens.slice(0));
+        });
+        sorter[key] = chain.createSorter();
+        return true;
+      }
+      return false;
+    });
+    return sorter;
+  }
+};
+
+module.exports = TokenChain;

node_modules/html-minifier-terser/src/utils.js

@@ -0,0 +1,31 @@
+'use strict';
+
+function createMap(values, ignoreCase) {
+  var map = {};
+  values.forEach(function(value) {
+    map[value] = 1;
+  });
+  return ignoreCase ? function(value) {
+    return map[value.toLowerCase()] === 1;
+  } : function(value) {
+    return map[value] === 1;
+  };
+}
+
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args);
+    promises.push(promise);
+  });
+  const data = await Promise.all(promises);
+  return str.replace(regex, () => data.shift());
+}
+
+
+exports.createMap = createMap;
+exports.createMapFromString = function(values, ignoreCase) {
+  return createMap(values.split(/,/), ignoreCase);
+};
+
+exports.replaceAsync = replaceAsync;