It appears you have a well-structured Git repository with various files, including SVG icons and HTML documents. Here's a brief overview:

backend/node_modules/chokidar-cli/index.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const throttle = require('lodash.throttle');
+const debounce = require('lodash.debounce');
+const chokidar = require('chokidar');
+const yargs = require('yargs');
+const { version: chokidarVersion } = require('chokidar/package.json');
+const { version } = require('./package.json');
+const utils = require('./utils');
+
+const EVENT_DESCRIPTIONS = {
+    add: 'File added',
+    addDir: 'Directory added',
+    unlink: 'File removed',
+    unlinkDir: 'Directory removed',
+    change: 'File changed'
+};
+
+const defaultOpts = {
+    debounce: 400,
+    throttle: 0,
+    followSymlinks: false,
+    ignore: null,
+    polling: false,
+    pollInterval: 100,
+    pollIntervalBinary: 300,
+    verbose: false,
+    silent: false,
+    initial: false,
+    command: null
+};
+
+const VERSION = `chokidar-cli: ${version}\nchokidar: ${chokidarVersion}`;
+
+const {argv} = yargs
+    .usage(
+        'Usage: chokidar <pattern> [<pattern>...] [options]\n\n' +
+        '<pattern>:\n' +
+        'Glob pattern to specify files to be watched.\n' +
+        'Multiple patterns can be watched by separating patterns with spaces.\n' +
+        'To prevent shell globbing, write pattern inside quotes.\n' +
+        'Guide to globs: https://github.com/isaacs/node-glob#glob-primer\n'
+    )
+    .example('chokidar "**/*.js" -c "npm run build-js"', 'build when any .js file changes')
+    .example('chokidar "**/*.js" "**/*.less"', 'output changes of .js and .less files')
+    .demand(1)
+    .option('c', {
+        alias: 'command',
+        describe: 'Command to run after each change. ' +
+                  'Needs to be surrounded with quotes when command contains ' +
+                  'spaces. Instances of `{path}` or `{event}` within the ' +
+                  'command will be replaced by the corresponding values from ' +
+                  'the chokidar event.'
+    })
+    .option('d', {
+        alias: 'debounce',
+        default: defaultOpts.debounce,
+        describe: 'Debounce timeout in ms for executing command',
+        type: 'number'
+    })
+    .option('t', {
+        alias: 'throttle',
+        default: defaultOpts.throttle,
+        describe: 'Throttle timeout in ms for executing command',
+        type: 'number'
+    })
+    .option('s', {
+        alias: 'follow-symlinks',
+        default: defaultOpts.followSymlinks,
+        describe: 'When not set, only the symlinks themselves will be watched ' +
+                  'for changes instead of following the link references and ' +
+                  'bubbling events through the links path',
+        type: 'boolean'
+    })
+    .option('i', {
+        alias: 'ignore',
+        describe: 'Pattern for files which should be ignored. ' +
+                  'Needs to be surrounded with quotes to prevent shell globbing. ' +
+                  'The whole relative or absolute path is tested, not just filename. ' +
+                  'Supports glob patters or regexes using format: /yourmatch/i'
+    })
+    .option('initial', {
+        describe: 'When set, command is initially run once',
+        default: defaultOpts.initial,
+        type: 'boolean'
+    })
+    .option('p', {
+        alias: 'polling',
+        describe: 'Whether to use fs.watchFile(backed by polling) instead of ' +
+                  'fs.watch. This might lead to high CPU utilization. ' +
+                  'It is typically necessary to set this to true to ' +
+                  'successfully watch files over a network, and it may be ' +
+                  'necessary to successfully watch files in other ' +
+                  'non-standard situations',
+        default: defaultOpts.polling,
+        type: 'boolean'
+    })
+    .option('poll-interval', {
+        describe: 'Interval of file system polling. Effective when --polling ' +
+                  'is set',
+        default: defaultOpts.pollInterval,
+        type: 'number'
+    })
+    .option('poll-interval-binary', {
+        describe: 'Interval of file system polling for binary files. ' +
+                  'Effective when --polling is set',
+        default: defaultOpts.pollIntervalBinary,
+        type: 'number'
+    })
+    .option('verbose', {
+        describe: 'When set, output is more verbose and human readable.',
+        default: defaultOpts.verbose,
+        type: 'boolean'
+    })
+    .option('silent', {
+        describe: 'When set, internal messages of chokidar-cli won\'t be written.',
+        default: defaultOpts.silent,
+        type: 'boolean'
+    })
+    .help('h')
+    .alias('h', 'help')
+    .alias('v', 'version')
+    .version(VERSION);
+
+function main() {
+    const userOpts = getUserOpts(argv);
+    const opts = Object.assign(defaultOpts, userOpts);
+    startWatching(opts);
+}
+
+function getUserOpts(argv) {
+    argv.patterns = argv._;
+    return argv;
+}
+
+// Estimates spent working hours based on commit dates
+function startWatching(opts) {
+    const chokidarOpts = createChokidarOpts(opts);
+    const watcher = chokidar.watch(opts.patterns, chokidarOpts);
+
+    let throttledRun = run;
+    if (opts.throttle > 0) {
+        throttledRun = throttle(run, opts.throttle);
+    }
+
+    let debouncedRun = throttledRun;
+    if (opts.debounce > 0) {
+        debouncedRun = debounce(throttledRun, opts.debounce);
+    }
+
+    watcher.on('all', (event, path) => {
+        const description = `${EVENT_DESCRIPTIONS[event]}:`;
+
+        if (opts.verbose) {
+            console.error(description, path);
+        } else if (!opts.silent) {
+            console.log(`${event}:${path}`);
+        }
+
+        // XXX: commands might be still run concurrently
+        if (opts.command) {
+            debouncedRun(
+                opts.command
+                    .replace(/\{path\}/ig, path)
+                    .replace(/\{event\}/ig, event)
+            );
+        }
+    });
+
+    watcher.on('error', error => {
+        console.error('Error:', error);
+        console.error(error.stack);
+    });
+
+    watcher.once('ready', () => {
+        const list = opts.patterns.join('", "');
+        if (!opts.silent) {
+            console.error('Watching', `"${list}" ..`);
+        }
+    });
+}
+
+function createChokidarOpts(opts) {
+    // Transform e.g. regex ignores to real regex objects
+    opts.ignore = _resolveIgnoreOpt(opts.ignore);
+
+    const chokidarOpts = {
+        followSymlinks: opts.followSymlinks,
+        usePolling: opts.polling,
+        interval: opts.pollInterval,
+        binaryInterval: opts.pollIntervalBinary,
+        ignoreInitial: !opts.initial
+    };
+
+    if (opts.ignore) {
+        chokidarOpts.ignored = opts.ignore;
+    }
+
+    return chokidarOpts;
+}
+
+// Takes string or array of strings
+function _resolveIgnoreOpt(ignoreOpt) {
+    if (!ignoreOpt) {
+        return ignoreOpt;
+    }
+
+    const ignores = Array.isArray(ignoreOpt) ? ignoreOpt : [ignoreOpt];
+
+    return ignores.map(ignore => {
+        const isRegex = ignore[0] === '/' && ignore[ignore.length - 1] === '/';
+        if (isRegex) {
+            // Convert user input to regex object
+            const match = ignore.match(/^\/(.*)\/(.*?)$/);
+            return new RegExp(match[1], match[2]);
+        }
+
+        return ignore;
+    });
+}
+
+function run(cmd) {
+    return utils.run(cmd)
+        .catch(error => {
+            console.error('Error when executing', cmd);
+            console.error(error.stack);
+        });
+}
+
+main();