diff --git a/node_modules/grunt-legacy-util/.idea/grunt-legacy-util.iml b/node_modules/grunt-legacy-util/.idea/grunt-legacy-util.iml
new file mode 100644
index 0000000..24643cc
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/grunt-legacy-util.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.idea/inspectionProfiles/Project_Default.xml b/node_modules/grunt-legacy-util/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..eff7139
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="JSHint" enabled="true" level="ERROR" enabled_by_default="true" />
+  </profile>
+</component>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.idea/jsLinters/jshint.xml b/node_modules/grunt-legacy-util/.idea/jsLinters/jshint.xml
new file mode 100644
index 0000000..b4ac480
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/jsLinters/jshint.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JSHintConfiguration" version="2.10.2" use-config-file="true" use-custom-config-file="true" custom-config-file-path="$PROJECT_DIR$/.jshintrc">
+    <option bitwise="true" />
+    <option browser="true" />
+    <option curly="true" />
+    <option eqeqeq="true" />
+    <option forin="true" />
+    <option maxerr="50" />
+    <option noarg="true" />
+    <option noempty="true" />
+    <option nonew="true" />
+    <option strict="true" />
+    <option undef="true" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.idea/modules.xml b/node_modules/grunt-legacy-util/.idea/modules.xml
new file mode 100644
index 0000000..c44f7b6
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/grunt-legacy-util.iml" filepath="$PROJECT_DIR$/.idea/grunt-legacy-util.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.idea/vcs.xml b/node_modules/grunt-legacy-util/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.idea/workspace.xml b/node_modules/grunt-legacy-util/.idea/workspace.xml
new file mode 100644
index 0000000..ad9084b
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.idea/workspace.xml
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="BranchesTreeState">
+    <expand>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="LOCAL_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="REMOTE_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="REMOTE_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="GROUP_NODE:origin" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+    </expand>
+    <select />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="1a694ac1-2850-4026-9e11-99b5d675b6c7" name="Default Changelist" comment="">
+      <change beforePath="$PROJECT_DIR$/CHANGELOG" beforeDir="false" afterPath="$PROJECT_DIR$/CHANGELOG" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="MacroExpansionManager">
+    <option name="directoryName" value="nozagdxa" />
+  </component>
+  <component name="ProjectId" id="1gHi811jaXoOhs5JOFLfwQV3GoI" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="nodejs_package_manager_path" value="npm" />
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="1a694ac1-2850-4026-9e11-99b5d675b6c7" name="Default Changelist" comment="" />
+      <created>1597777756914</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1597777756914</updated>
+      <workItem from="1597777758488" duration="990000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State />
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-util/.jshintrc b/node_modules/grunt-legacy-util/.jshintrc
new file mode 100644
index 0000000..2b7e39b
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.jshintrc
@@ -0,0 +1,14 @@
+{
+  "curly": true,
+  "eqeqeq": true,
+  "immed": true,
+  "latedef": "nofunc",
+  "newcap": true,
+  "noarg": true,
+  "sub": true,
+  "undef": true,
+  "unused": true,
+  "boss": true,
+  "eqnull": true,
+  "node": true
+}
diff --git a/node_modules/grunt-legacy-util/.travis.yml b/node_modules/grunt-legacy-util/.travis.yml
new file mode 100644
index 0000000..607bbbd
--- /dev/null
+++ b/node_modules/grunt-legacy-util/.travis.yml
@@ -0,0 +1,9 @@
+sudo: false
+language: node_js
+node_js:
+  - "8"
+  - "10"
+  - "12"
+  - "14"
+matrix:
+  fast_finish: true
diff --git a/node_modules/grunt-legacy-util/CHANGELOG b/node_modules/grunt-legacy-util/CHANGELOG
new file mode 100644
index 0000000..5eb979e
--- /dev/null
+++ b/node_modules/grunt-legacy-util/CHANGELOG
@@ -0,0 +1,21 @@
+v2.0.0:
+  date: 2020-08-18
+  changes:
+    - Update dependencies
+    - Fix Buffer warnings by switching to Buffer.from()
+    - Avoid detecting AsyncFunction as a generic object
+v1.1.1:
+  date: 2018-05-21
+  changes:
+    - Fixes lodash versioning
+
+v1.1.0:
+  date: 2018-05-19
+  changes:
+    - Security fixes
+
+v1.0.0:
+  date: 2016-04-03
+  changes:
+    - test fixes for Windows
+    - update to use the svg badge
diff --git a/node_modules/grunt-legacy-util/Gruntfile.js b/node_modules/grunt-legacy-util/Gruntfile.js
new file mode 100644
index 0000000..d7e5845
--- /dev/null
+++ b/node_modules/grunt-legacy-util/Gruntfile.js
@@ -0,0 +1,30 @@
+'use strict';
+
+module.exports = function(grunt) {
+
+  grunt.initConfig({
+    jshint: {
+      options: {
+        jshintrc: '.jshintrc',
+      },
+      all: ['*.js', 'test/*.js'],
+    },
+    nodeunit: {
+      util: ['test/index.js']
+    },
+    watch: {
+      all: {
+        files: ['<%= jshint.all %>'],
+        tasks: ['test'],
+      },
+    },
+  });
+
+  grunt.loadNpmTasks('grunt-contrib-jshint');
+  grunt.loadNpmTasks('grunt-contrib-nodeunit');
+  grunt.loadNpmTasks('grunt-contrib-watch');
+
+  grunt.registerTask('test', ['jshint', 'nodeunit']);
+  grunt.registerTask('default', ['test', 'watch']);
+
+};
diff --git a/node_modules/grunt-legacy-util/LICENSE-MIT b/node_modules/grunt-legacy-util/LICENSE-MIT
new file mode 100644
index 0000000..8ac94f0
--- /dev/null
+++ b/node_modules/grunt-legacy-util/LICENSE-MIT
@@ -0,0 +1,22 @@
+Copyright (c) 2016 "Cowboy" Ben Alman
+
+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.
diff --git a/node_modules/grunt-legacy-util/README.md b/node_modules/grunt-legacy-util/README.md
new file mode 100644
index 0000000..1cdd1f7
--- /dev/null
+++ b/node_modules/grunt-legacy-util/README.md
@@ -0,0 +1,32 @@
+# grunt-legacy-util
+> deprecated utilities from grunt
+
+[![Build Status: Linux](https://travis-ci.org/gruntjs/grunt-legacy-util.svg?branch=master)](https://travis-ci.org/gruntjs/grunt-legacy-util)
+[![Build status: Windows](https://ci.appveyor.com/api/projects/status/63a5pjh5hy0wgtx0/branch/master?svg=true)](https://ci.appveyor.com/project/gruntjs/grunt-legacy-util/branch/master)
+[![Built with Grunt](https://cdn.gruntjs.com/builtwith.svg)](http://gruntjs.com/)
+
+With the next major release of Grunt, we will no longer support these APIs.  Where possible, please use the recommended modules in their place.  If you would like to support or improve any of these APIs, please notify us when you have published a backwards compatible npm module&mdash;we will then recommend its usage here.
+
+`grunt.util.namespace` use [getobject]  
+`grunt.util.hooker` use [hooker]  
+`grunt.util.async` use [async]  
+`grunt.util._` use [lodash]  
+`grunt.util.exit` use [exit]  
+`grunt.util.callbackify`  
+`grunt.util.error`  
+`grunt.util.linefeed`  
+`grunt.util.normalizelf`  
+`grunt.util.kindOf` use [lodash]  
+`grunt.util.toArray`
+`grunt.util.repeat`  
+`grunt.util.pluralize`  
+`grunt.util.recurse` use [traverse]  
+`grunt.util.spawn` use [require('child_process').spawn]  
+
+[getobject]: https://www.npmjs.org/package/getobject
+[hooker]: https://www.npmjs.org/package/hooker
+[async]: https://www.npmjs.org/package/async
+[lodash]: https://www.npmjs.org/package/lodash
+[exit]: https://www.npmjs.org/package/exit
+[traverse]: https://www.npmjs.org/package/traverse
+[require('child_process').spawn]: https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
diff --git a/node_modules/grunt-legacy-util/appveyor.yml b/node_modules/grunt-legacy-util/appveyor.yml
new file mode 100644
index 0000000..87e8c4d
--- /dev/null
+++ b/node_modules/grunt-legacy-util/appveyor.yml
@@ -0,0 +1,27 @@
+# Fix line endings on Windows
+init:
+  - git config --global core.autocrlf true
+# What combinations to test
+environment:
+  matrix:
+    - nodejs_version: "8"
+    - nodejs_version: "10"
+    - nodejs_version: "12"
+platform:
+  - x86
+  - x64
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - npm install
+test_script:
+  # Output useful info for debugging.
+  - node --version && npm --version
+  # We test multiple Windows shells because of prior stdout buffering issues
+  # filed against Grunt. https://github.com/joyent/node/issues/3584
+  - ps: "npm test # PowerShell" # Pass comment to PS for easier debugging
+  - cmd: npm test
+build: off
+matrix:
+  fast_finish: true
+cache:
+  - node_modules -> package.json                                        # local npm modules
diff --git a/node_modules/grunt-legacy-util/index.js b/node_modules/grunt-legacy-util/index.js
new file mode 100644
index 0000000..a833e75
--- /dev/null
+++ b/node_modules/grunt-legacy-util/index.js
@@ -0,0 +1,202 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2016 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+// Nodejs libs.
+var spawn = require('child_process').spawn;
+var nodeUtil = require('util');
+var path = require('path');
+
+// The module to be exported.
+var util = module.exports = {};
+
+util.namespace = require('getobject');
+
+// External libs.
+util.hooker = require('hooker');
+util.async = require('async');
+// Dont pollute other lodash: https://github.com/gruntjs/grunt-legacy-util/issues/17
+var _ = util._ = require('lodash').runInContext();
+var which = require('which').sync;
+// Instead of process.exit. See https://github.com/cowboy/node-exit
+util.exit = require('exit');
+
+// Mixin Underscore.string methods.
+_.str = require('underscore.string');
+_.mixin(_.str.exports());
+
+// Return a function that normalizes the given function either returning a
+// value or accepting a "done" callback that accepts a single value.
+util.callbackify = function(fn) {
+  return function callbackable() {
+    // Invoke original function, getting its result.
+    var result = fn.apply(this, arguments);
+    // If the same number or less arguments were specified than fn accepts,
+    // assume the "done" callback was already handled.
+    var length = arguments.length;
+    if (length === fn.length) { return; }
+    // Otherwise, if the last argument is a function, assume it is a "done"
+    // callback and call it.
+    var done = arguments[length - 1];
+    if (typeof done === 'function') { done(result); }
+  };
+};
+
+// Create a new Error object, with an origError property that will be dumped
+// if grunt was run with the --debug=9 option.
+util.error = function(err, origError) {
+  if (!nodeUtil.isError(err)) { err = new Error(err); }
+  if (origError) { err.origError = origError; }
+  return err;
+};
+
+// The line feed char for the current system.
+util.linefeed = process.platform === 'win32' ? '\r\n' : '\n';
+
+// Normalize linefeeds in a string.
+util.normalizelf = function(str) {
+  return str.replace(/\r\n|\n/g, util.linefeed);
+};
+
+// What "kind" is a value?
+// I really need to rework https://github.com/cowboy/javascript-getclass
+var kindsOf = {};
+'Number String Boolean Function AsyncFunction RegExp Array Date Error'.split(' ').forEach(function(k) {
+  kindsOf['[object ' + k + ']'] = k.toLowerCase();
+});
+util.kindOf = function(value) {
+  // Null or undefined.
+  if (value == null) { return String(value); }
+  // Everything else.
+  return kindsOf[kindsOf.toString.call(value)] || 'object';
+};
+
+// Coerce something to an Array.
+util.toArray = _.toArray;
+
+// Return the string `str` repeated `n` times.
+util.repeat = function(n, str) {
+  return new Array(n + 1).join(str || ' ');
+};
+
+// Given str of "a/b", If n is 1, return "a" otherwise "b".
+util.pluralize = function(n, str, separator) {
+  var parts = str.split(separator || '/');
+  return n === 1 ? (parts[0] || '') : (parts[1] || '');
+};
+
+// Recurse through objects and arrays, executing fn for each non-object.
+util.recurse = function(value, fn, fnContinue) {
+  function recurse(value, fn, fnContinue, state) {
+    var error;
+    if (state.objs.indexOf(value) !== -1) {
+      error = new Error('Circular reference detected (' + state.path + ')');
+      error.path = state.path;
+      throw error;
+    }
+    var obj, key;
+    if (fnContinue && fnContinue(value) === false) {
+      // Skip value if necessary.
+      return value;
+    } else if (util.kindOf(value) === 'array') {
+      // If value is an array, recurse.
+      return value.map(function(item, index) {
+        return recurse(item, fn, fnContinue, {
+          objs: state.objs.concat([value]),
+          path: state.path + '[' + index + ']',
+        });
+      });
+    } else if (util.kindOf(value) === 'object' && !Buffer.isBuffer(value)) {
+      // If value is an object, recurse.
+      obj = {};
+      for (key in value) {
+        obj[key] = recurse(value[key], fn, fnContinue, {
+          objs: state.objs.concat([value]),
+          path: state.path + (/\W/.test(key) ? '["' + key + '"]' : '.' + key),
+        });
+      }
+      return obj;
+    } else {
+      // Otherwise pass value into fn and return.
+      return fn(value);
+    }
+  }
+  return recurse(value, fn, fnContinue, {objs: [], path: ''});
+};
+
+// Spawn a child process, capturing its stdout and stderr.
+util.spawn = function(opts, done) {
+  // Build a result object and pass it (among other things) into the
+  // done function.
+  var callDone = function(code, stdout, stderr) {
+    // Remove trailing whitespace (newline)
+    stdout = _.rtrim(stdout);
+    stderr = _.rtrim(stderr);
+    // Create the result object.
+    var result = {
+      stdout: stdout,
+      stderr: stderr,
+      code: code,
+      toString: function() {
+        if (code === 0) {
+          return stdout;
+        } else if ('fallback' in opts) {
+          return opts.fallback;
+        } else if (opts.grunt) {
+          // grunt.log.error uses standard out, to be fixed in 0.5.
+          return stderr || stdout;
+        }
+        return stderr;
+      }
+    };
+    // On error (and no fallback) pass an error object, otherwise pass null.
+    done(code === 0 || 'fallback' in opts ? null : new Error(stderr), result, code);
+  };
+
+  var cmd, args;
+  var pathSeparatorRe = /[\\\/]/g;
+  if (opts.grunt) {
+    cmd = process.execPath;
+    args = process.execArgv.concat(process.argv[1], opts.args);
+  } else {
+    // On Windows, child_process.spawn will only file .exe files in the PATH,
+    // not other executable types (grunt issue #155).
+    try {
+      if (!pathSeparatorRe.test(opts.cmd)) {
+        // Only use which if cmd has no path component.
+        cmd = which(opts.cmd);
+      } else {
+        cmd = opts.cmd.replace(pathSeparatorRe, path.sep);
+      }
+    } catch (err) {
+      callDone(127, '', String(err));
+      return;
+    }
+    args = opts.args || [];
+  }
+
+  var child = spawn(cmd, args, opts.opts);
+  var stdout = Buffer.from('');
+  var stderr = Buffer.from('');
+  if (child.stdout) {
+    child.stdout.on('data', function(buf) {
+      stdout = Buffer.concat([stdout, Buffer.from(buf)]);
+    });
+  }
+  if (child.stderr) {
+    child.stderr.on('data', function(buf) {
+      stderr = Buffer.concat([stderr, Buffer.from(buf)]);
+    });
+  }
+  child.on('close', function(code) {
+    callDone(code, stdout.toString(), stderr.toString());
+  });
+  return child;
+};
diff --git a/node_modules/grunt-legacy-util/package.json b/node_modules/grunt-legacy-util/package.json
new file mode 100644
index 0000000..5b8dffa
--- /dev/null
+++ b/node_modules/grunt-legacy-util/package.json
@@ -0,0 +1,71 @@
+{
+  "_from": "grunt-legacy-util@~2.0.0",
+  "_id": "grunt-legacy-util@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-ZEmYFB44bblwPE2oz3q3ygfF6hseQja9tx8I3UZIwbUik32FMWewA+d1qSFicMFB+8dNXDkh35HcDCWlpRsGlA==",
+  "_location": "/grunt-legacy-util",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "grunt-legacy-util@~2.0.0",
+    "name": "grunt-legacy-util",
+    "escapedName": "grunt-legacy-util",
+    "rawSpec": "~2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "~2.0.0"
+  },
+  "_requiredBy": [
+    "/grunt"
+  ],
+  "_resolved": "https://registry.npmjs.org/grunt-legacy-util/-/grunt-legacy-util-2.0.0.tgz",
+  "_shasum": "34d20f2a26c6adebfe9a9bdc8823f7016b0369c3",
+  "_spec": "grunt-legacy-util@~2.0.0",
+  "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\grunt",
+  "author": {
+    "name": "\"Cowboy\" Ben Alman",
+    "url": "http://benalman.com/"
+  },
+  "bugs": {
+    "url": "http://github.com/gruntjs/grunt-legacy-util/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "async": "~1.5.2",
+    "exit": "~0.1.1",
+    "getobject": "~0.1.0",
+    "hooker": "~0.2.3",
+    "lodash": "~4.17.20",
+    "underscore.string": "~3.3.5",
+    "which": "~1.3.0"
+  },
+  "deprecated": false,
+  "description": "Some old grunt utils provided for backwards compatibility.",
+  "devDependencies": {
+    "grunt": "^1.2.1",
+    "grunt-cli": "^1.3.2",
+    "grunt-contrib-jshint": "^2.1.0",
+    "grunt-contrib-nodeunit": "^2.1.0",
+    "grunt-contrib-watch": "^1.1.0",
+    "temporary": "0.0.8"
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "homepage": "http://gruntjs.com/",
+  "keywords": [
+    "grunt",
+    "legacy"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "grunt-legacy-util",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/gruntjs/grunt-legacy-util.git"
+  },
+  "scripts": {
+    "test": "grunt test"
+  },
+  "version": "2.0.0"
+}
diff --git a/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv-child.js b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv-child.js
new file mode 100644
index 0000000..f0d1d1f
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv-child.js
@@ -0,0 +1,7 @@
+module.exports = function(grunt) {
+
+  grunt.registerTask('default', function(text) {
+    console.log('OUTPUT: ' + process.execArgv.join(' '));
+  });
+
+};
diff --git a/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv.js b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv.js
new file mode 100644
index 0000000..7ad3db0
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-execArgv.js
@@ -0,0 +1,17 @@
+module.exports = function(grunt) {
+
+  var util = require('../../');
+
+  grunt.registerTask('default', function(text) {
+    var done = this.async();
+    util.spawn({
+      grunt: true,
+      args: ['--gruntfile', 'Gruntfile-execArgv-child.js'],
+    }, function(err, result, code) {
+      var matches = result.stdout.match(/^(OUTPUT: .*)/m);
+      console.log(matches ? matches[1] : '');
+      done();
+    });
+  });
+
+};
diff --git a/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-print-text.js b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-print-text.js
new file mode 100644
index 0000000..910197d
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/Gruntfile-print-text.js
@@ -0,0 +1,8 @@
+module.exports = function(grunt) {
+
+  grunt.registerTask('print', 'Print the specified text.', function(text) {
+    console.log('OUTPUT: ' + text);
+    // console.log(process.cwd());
+  });
+
+};
diff --git a/node_modules/grunt-legacy-util/test/fixtures/exec.cmd b/node_modules/grunt-legacy-util/test/fixtures/exec.cmd
new file mode 100644
index 0000000..6e4a52b
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/exec.cmd
@@ -0,0 +1 @@
+@echo done
diff --git a/node_modules/grunt-legacy-util/test/fixtures/exec.sh b/node_modules/grunt-legacy-util/test/fixtures/exec.sh
new file mode 100644
index 0000000..8890799
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/exec.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "done"
diff --git a/node_modules/grunt-legacy-util/test/fixtures/spawn-multibyte.js b/node_modules/grunt-legacy-util/test/fixtures/spawn-multibyte.js
new file mode 100644
index 0000000..b592341
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/spawn-multibyte.js
@@ -0,0 +1,17 @@
+// This is a test fixture for a case where spawn receives incomplete
+// multibyte strings in separate data events.
+
+// A multibyte buffer containing all our output. We will slice it later.
+// In this case we are using a Japanese word for hello / good day, where each
+// character takes three bytes.
+var fullOutput = Buffer.from('こんにちは');
+
+// Output one full character and one third of a character
+process.stdout.write(fullOutput.slice(0, 4));
+
+// Output the rest of the string
+process.stdout.write(fullOutput.slice(4));
+
+// Do the same for stderr
+process.stderr.write(fullOutput.slice(0, 4));
+process.stderr.write(fullOutput.slice(4));
diff --git a/node_modules/grunt-legacy-util/test/fixtures/spawn.js b/node_modules/grunt-legacy-util/test/fixtures/spawn.js
new file mode 100644
index 0000000..14c7029
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/fixtures/spawn.js
@@ -0,0 +1,8 @@
+
+var code = Number(process.argv[2]);
+
+process.stdout.write('stdout\n');
+process.stderr.write('stderr\n');
+
+// Instead of process.exit. See https://github.com/cowboy/node-exit
+require('exit')(code);
diff --git a/node_modules/grunt-legacy-util/test/index.js b/node_modules/grunt-legacy-util/test/index.js
new file mode 100644
index 0000000..55cf79f
--- /dev/null
+++ b/node_modules/grunt-legacy-util/test/index.js
@@ -0,0 +1,554 @@
+'use strict';
+
+var util = require('../');
+
+var fs = require('fs');
+var path = require('path');
+
+var Tempfile = require('temporary/lib/file');
+
+exports['util.callbackify'] = {
+  'return': function(test) {
+    test.expect(1);
+    // This function returns a value.
+    function add(a, b) {
+      return a + b;
+    }
+    util.callbackify(add)(1, 2, function(result) {
+      test.equal(result, 3, 'should be the correct result.');
+      test.done();
+    });
+  },
+  'callback (sync)': function(test) {
+    test.expect(1);
+    // This function accepts a callback which it calls synchronously.
+    function add(a, b, done) {
+      done(a + b);
+    }
+    util.callbackify(add)(1, 2, function(result) {
+      test.equal(result, 3, 'should be the correct result.');
+      test.done();
+    });
+  },
+  'callback (async)': function(test) {
+    test.expect(1);
+    // This function accepts a callback which it calls asynchronously.
+    function add(a, b, done) {
+      setTimeout(done.bind(null, a + b), 0);
+    }
+    util.callbackify(add)(1, 2, function(result) {
+      test.equal(result, 3, 'should be the correct result.');
+      test.done();
+    });
+  }
+};
+
+exports['util'] = {
+  'error': function(test) {
+    test.expect(9);
+    var origError = new Error('Original error.');
+
+    var err = util.error('Test message.');
+    test.ok(err instanceof Error, 'Should be an Error.');
+    test.equal(err.name, 'Error', 'Should be an Error.');
+    test.equal(err.message, 'Test message.', 'Should have the correct message.');
+
+    err = util.error('Test message.', origError);
+    test.ok(err instanceof Error, 'Should be an Error.');
+    test.equal(err.name, 'Error', 'Should be an Error.');
+    test.equal(err.message, 'Test message.', 'Should have the correct message.');
+    test.equal(err.origError, origError, 'Should reflect the original error.');
+
+    var newError = new Error('Test message.');
+    err = util.error(newError, origError);
+    test.equal(err, newError, 'Should be the passed-in Error.');
+    test.equal(err.origError, origError, 'Should reflect the original error.');
+    test.done();
+  },
+  'linefeed': function(test) {
+    test.expect(1);
+    if (process.platform === 'win32') {
+      test.equal(util.linefeed, '\r\n', 'linefeed should be operating-system appropriate.');
+    } else {
+      test.equal(util.linefeed, '\n', 'linefeed should be operating-system appropriate.');
+    }
+    test.done();
+  },
+  'normalizelf': function(test) {
+    test.expect(1);
+    if (process.platform === 'win32') {
+      test.equal(util.normalizelf('foo\nbar\r\nbaz\r\n\r\nqux\n\nquux'), 'foo\r\nbar\r\nbaz\r\n\r\nqux\r\n\r\nquux', 'linefeeds should be normalized');
+    } else {
+      test.equal(util.normalizelf('foo\nbar\r\nbaz\r\n\r\nqux\n\nquux'), 'foo\nbar\nbaz\n\nqux\n\nquux', 'linefeeds should be normalized');
+    }
+    test.done();
+  }
+};
+
+exports['util.spawn'] = {
+  setUp: function(done) {
+    this.script = path.resolve('test/fixtures/spawn.js');
+    done();
+  },
+  'exit code 0': function(test) {
+    test.expect(6);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ this.script, 0 ],
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.equals(result.stdout, 'stdout');
+      test.equals(result.stderr, 'stderr');
+      test.equals(result.code, 0);
+      test.equals(String(result), 'stdout');
+      test.done();
+    });
+  },
+  'exit code 0, fallback': function(test) {
+    test.expect(6);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ this.script, 0 ],
+      fallback: 'ignored if exit code is 0'
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.equals(result.stdout, 'stdout');
+      test.equals(result.stderr, 'stderr');
+      test.equals(result.code, 0);
+      test.equals(String(result), 'stdout');
+      test.done();
+    });
+  },
+  'non-zero exit code': function(test) {
+    test.expect(7);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ this.script, 123 ],
+    }, function(err, result, code) {
+      test.ok(err instanceof Error);
+      test.equals(err.message, 'stderr');
+      test.equals(code, 123);
+      test.equals(result.stdout, 'stdout');
+      test.equals(result.stderr, 'stderr');
+      test.equals(result.code, 123);
+      test.equals(String(result), 'stderr');
+      test.done();
+    });
+  },
+  'non-zero exit code, fallback': function(test) {
+    test.expect(6);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ this.script, 123 ],
+      fallback: 'custom fallback'
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 123);
+      test.equals(result.stdout, 'stdout');
+      test.equals(result.stderr, 'stderr');
+      test.equals(result.code, 123);
+      test.equals(String(result), 'custom fallback');
+      test.done();
+    });
+  },
+  'cmd not found': function(test) {
+    test.expect(3);
+    util.spawn({
+      cmd: 'nodewtfmisspelled',
+    }, function(err, result, code) {
+      test.ok(err instanceof Error);
+      test.equals(code, 127);
+      test.equals(result.code, 127);
+      test.done();
+    });
+  },
+  'cmd not found, fallback': function(test) {
+    test.expect(4);
+    util.spawn({
+      cmd: 'nodewtfmisspelled',
+      fallback: 'use a fallback or good luck'
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 127);
+      test.equals(result.code, 127);
+      test.equals(String(result), 'use a fallback or good luck');
+      test.done();
+    });
+  },
+  'cmd not in path': function(test) {
+    test.expect(6);
+    var win32 = process.platform === 'win32';
+    util.spawn({
+      cmd: 'test\\fixtures\\exec' + (win32 ? '.cmd' : '.sh'),
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.equals(result.stdout, 'done');
+      test.equals(result.stderr, '');
+      test.equals(result.code, 0);
+      test.equals(String(result), 'done');
+      test.done();
+    });
+  },
+  'cmd not in path (with cwd)': function(test) {
+    test.expect(6);
+    var win32 = process.platform === 'win32';
+    util.spawn({
+      cmd: './exec' + (win32 ? '.cmd' : '.sh'),
+      opts: {cwd: 'test/fixtures'},
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.equals(result.stdout, 'done');
+      test.equals(result.stderr, '');
+      test.equals(result.code, 0);
+      test.equals(String(result), 'done');
+      test.done();
+    });
+  },
+  'grunt': function(test) {
+    test.expect(3);
+    util.spawn({
+      grunt: true,
+      args: [ '--gruntfile', 'test/fixtures/Gruntfile-print-text.js', 'print:foo' ],
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.ok(/^OUTPUT: foo/m.test(result.stdout), 'stdout should contain output indicating the grunt task was run.');
+      test.done();
+    });
+  },
+  'grunt (with cwd)': function(test) {
+    test.expect(3);
+    util.spawn({
+      grunt: true,
+      args: [ '--gruntfile', 'Gruntfile-print-text.js', 'print:foo' ],
+      opts: {cwd: 'test/fixtures'},
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.ok(/^OUTPUT: foo/m.test(result.stdout), 'stdout should contain output indicating the grunt task was run.');
+      test.done();
+    });
+  },
+  'grunt passes execArgv': function(test) {
+    test.expect(3);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ '--harmony', process.argv[1], '--gruntfile', 'test/fixtures/Gruntfile-execArgv.js'],
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.ok(/^OUTPUT: --harmony/m.test(result.stdout), 'stdout should contain passed-through process.execArgv.');
+      test.done();
+    });
+  },
+  'grunt result.toString() with error': function(test) {
+    // grunt.log.error uses standard out, to be fixed in 0.5.
+    test.expect(4);
+    util.spawn({
+      grunt: true,
+      args: [ 'nonexistentTask' ]
+    }, function(err, result, code) {
+      test.ok(err instanceof Error, 'Should be an Error.');
+      test.equal(err.name, 'Error', 'Should be an Error.');
+      test.equals(code, 3);
+      test.ok(/Warning: Task "nonexistentTask" not found./m.test(result.toString()), 'stdout should contain output indicating the grunt task was (attempted to be) run.');
+      test.done();
+    });
+  },
+  'custom stdio stream(s)': function(test) {
+    test.expect(6);
+    var stdoutFile = new Tempfile();
+    var stderrFile = new Tempfile();
+    var stdout = fs.openSync(stdoutFile.path, 'a');
+    var stderr = fs.openSync(stderrFile.path, 'a');
+    var child = util.spawn({
+      cmd: process.execPath,
+      args: [ this.script, 0 ],
+      opts: {stdio: [null, stdout, stderr]},
+    }, function(err, result, code) {
+      test.equals(code, 0);
+      test.equals(String(fs.readFileSync(stdoutFile.path)), 'stdout\n', 'Child process stdout should have been captured via custom stream.');
+      test.equals(String(fs.readFileSync(stderrFile.path)), 'stderr\n', 'Child process stderr should have been captured via custom stream.');
+      stdoutFile.unlinkSync();
+      stderrFile.unlinkSync();
+      test.equals(result.stdout, '', 'Nothing will be passed to the stdout string when spawn stdio is a custom stream.');
+      test.done();
+    });
+    test.ok(!child.stdout, 'child should not have a stdout property.');
+    test.ok(!child.stderr, 'child should not have a stderr property.');
+  },
+};
+
+exports['util.spawn.multibyte'] = {
+  setUp: function(done) {
+    this.script = path.resolve('test/fixtures/spawn-multibyte.js');
+    done();
+  },
+  'partial stdout': function(test) {
+    test.expect(4);
+    util.spawn({
+      cmd: process.execPath,
+      args: [ this.script ],
+    }, function(err, result, code) {
+      test.equals(err, null);
+      test.equals(code, 0);
+      test.equals(result.stdout, 'こんにちは');
+      test.equals(result.stderr, 'こんにちは');
+      test.done();
+    });
+  }
+};
+
+exports['util.underscore.string'] = function(test) {
+  test.expect(4);
+  test.equals(util._.trim('    foo     '), 'foo', 'Should have trimmed the string.');
+  test.equals(util._.capitalize('foo'), 'Foo', 'Should have capitalized the first letter.');
+  test.equals(util._.words('one two three').length, 3, 'Should have counted three words.');
+  test.ok(util._.isBlank(' '), 'Should be blank.');
+  test.done();
+};
+
+function getType(val) {
+  if (Buffer.isBuffer(val)) { return 'buffer'; }
+  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase();
+}
+
+exports['util.recurse'] = {
+  setUp: function(done) {
+    this.typeValue = function(value) {
+      return {
+        value: value,
+        type: getType(value),
+      };
+    };
+    done();
+  },
+  'primitives': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      bool: true,
+      num: 1,
+      str: 'foo',
+      nul: null,
+      undef: undefined,
+    }, this.typeValue);
+    var expected = {
+      bool: {type: 'boolean', value: true},
+      num: {type: 'number', value: 1},
+      str: {type: 'string', value: 'foo'},
+      nul: {type: 'null', value: null},
+      undef: {type: 'undefined', value: undefined},
+    };
+    test.deepEqual(actual, expected, 'Should process primitive values.');
+    test.done();
+  },
+  'array': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      arr: [
+        true,
+        1,
+        'foo',
+        null,
+        undefined,
+        [
+          true,
+          1,
+          'foo',
+          null,
+          undefined,
+        ],
+      ],
+    }, this.typeValue);
+    var expected = {
+      arr: [
+        {type: 'boolean', value: true},
+        {type: 'number', value: 1},
+        {type: 'string', value: 'foo'},
+        {type: 'null', value: null},
+        {type: 'undefined', value: undefined},
+        [
+          {type: 'boolean', value: true},
+          {type: 'number', value: 1},
+          {type: 'string', value: 'foo'},
+          {type: 'null', value: null},
+          {type: 'undefined', value: undefined},
+        ],
+      ],
+    };
+    test.deepEqual(actual, expected, 'Should recurse over arrays.');
+    test.done();
+  },
+  'object': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      obj: {
+        bool: true,
+        num: 1,
+        str: 'foo',
+        nul: null,
+        undef: undefined,
+        obj: {
+          bool: true,
+          num: 1,
+          str: 'foo',
+          nul: null,
+          undef: undefined,
+        },
+      },
+    }, this.typeValue);
+    var expected = {
+      obj: {
+        bool: {type: 'boolean', value: true},
+        num: {type: 'number', value: 1},
+        str: {type: 'string', value: 'foo'},
+        nul: {type: 'null', value: null},
+        undef: {type: 'undefined', value: undefined},
+        obj: {
+          bool: {type: 'boolean', value: true},
+          num: {type: 'number', value: 1},
+          str: {type: 'string', value: 'foo'},
+          nul: {type: 'null', value: null},
+          undef: {type: 'undefined', value: undefined},
+        },
+      },
+    };
+    test.deepEqual(actual, expected, 'Should recurse over objects.');
+    test.done();
+  },
+  'array in object': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      obj: {
+        arr: [
+          true,
+          1,
+          'foo',
+          null,
+          undefined,
+        ],
+      },
+    }, this.typeValue);
+    var expected = {
+      obj: {
+        arr: [
+          {type: 'boolean', value: true},
+          {type: 'number', value: 1},
+          {type: 'string', value: 'foo'},
+          {type: 'null', value: null},
+          {type: 'undefined', value: undefined},
+        ],
+      },
+    };
+    test.deepEqual(actual, expected, 'Should recurse over arrays in objects.');
+    test.done();
+  },
+  'object in array': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      arr: [
+        true,
+        {
+          num: 1,
+          str: 'foo',
+        },
+        null,
+        undefined,
+      ],
+    }, this.typeValue);
+    var expected = {
+      arr: [
+        {type: 'boolean', value: true},
+        {
+          num: {type: 'number', value: 1},
+          str: {type: 'string', value: 'foo'},
+        },
+        {type: 'null', value: null},
+        {type: 'undefined', value: undefined},
+      ],
+    };
+    test.deepEqual(actual, expected, 'Should recurse over objects in arrays.');
+    test.done();
+  },
+  'buffer': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      buf: Buffer.from('buf'),
+    }, this.typeValue);
+    var expected = {
+      buf: {type: 'buffer', value: Buffer.from('buf')},
+    };
+    test.deepEqual(actual, expected, 'Should not mangle Buffer instances.');
+    test.done();
+  },
+  'inherited properties': function(test) {
+    test.expect(1);
+    var actual = util.recurse({
+      obj: Object.create({num: 1}, {
+        str: {value: 'foo', enumerable: true},
+        ignored: {value: 'ignored', enumerable: false},
+      }),
+    }, this.typeValue);
+    var expected = {
+      obj: {
+        num: {type: 'number', value: 1},
+        str: {type: 'string', value: 'foo'},
+      }
+    };
+    test.deepEqual(actual, expected, 'Should enumerate inherited object properties.');
+    test.done();
+  },
+  'circular references': function(test) {
+    test.expect(6);
+    function assertErrorWithPath(expectedPath) {
+      return function(actual) {
+        return actual.path === expectedPath &&
+          actual.message === 'Circular reference detected (' + expectedPath + ')';
+      };
+    }
+    test.doesNotThrow(function() {
+      var obj = {
+        // wat
+        a:[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
+        // does
+        b:[[[[],[[[],[[[[],[[[],[[[],[[[],[[[],[[[[],[[]]]]]]]]]]]]]]]]]]]]],
+        // it
+        c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{o:{p:{q:{r:{s:{}}}}}}}}}}}}}}}}},
+        // mean
+        t:[{u:[{v:[[[[],[[[],[[[{w:[{x:[[[],[[[{y:[[1]]}]]]]]}]}]]]]]]]]}]}],
+      };
+      util.recurse(obj, function(v) { return v; });
+    }, 'Should not throw when no circular reference is detected.');
+    test.throws(function() {
+      var obj = {a: 1, b: 2};
+      obj.obj = obj;
+      util.recurse(obj, function(v) { return v; });
+    }, assertErrorWithPath('.obj'), 'Should throw when a circular reference is detected.');
+    test.throws(function() {
+      var obj = {a:{'b b':{'c-c':{d_d:{e:{f:{g:{h:{i:{j:{k:{l:{}}}}}}}}}}}}};
+      obj.a['b b']['c-c'].d_d.e.f.g.h.i.j.k.l.obj = obj;
+      util.recurse(obj, function(v) { return v; });
+    }, assertErrorWithPath('.a["b b"]["c-c"].d_d.e.f.g.h.i.j.k.l.obj'), 'Should throw when a circular reference is detected.');
+    test.throws(function() {
+      var obj = {a: 1, b: 2};
+      obj.arr = [1, 2, obj, 3, 4];
+      util.recurse(obj, function(v) { return v; });
+    }, assertErrorWithPath('.arr[2]'), 'Should throw when a circular reference is detected.');
+    test.throws(function() {
+      var obj = {a: 1, b: 2};
+      obj.arr = [{a:[1,{b:[2,{c:[3,obj,4]},5]},6]},7];
+      util.recurse(obj, function(v) { return v; });
+    }, assertErrorWithPath('.arr[0].a[1].b[1].c[1]'), 'Should throw when a circular reference is detected.');
+    test.throws(function() {
+      var obj = {a: 1, b: 2};
+      obj.arr = [];
+      obj.arr.push(0,{a:[1,{b:[2,{c:[3,obj.arr,4]},5]},6]},7);
+      util.recurse(obj, function(v) { return v; });
+    }, assertErrorWithPath('.arr[1].a[1].b[1].c[1]'), 'Should throw when a circular reference is detected.');
+    test.done();
+  },
+};