tailwindcss 0.0.0-insiders.de00a62 → 0.0.0-insiders.deb33a9

package/lib/cli/build/plugin.js

@@ -1,378 +0,0 @@
-// @ts-check
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createProcessor", {
-    enumerable: true,
-    get: function() {
-        return createProcessor;
-    }
-});
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _postcssloadconfig = /*#__PURE__*/ _interop_require_default(require("postcss-load-config"));
-const _lilconfig = require("lilconfig");
-const _plugins = /*#__PURE__*/ _interop_require_default(require("postcss-load-config/src/plugins" // Little bit scary, looking at private/internal API
-));
-const _options = /*#__PURE__*/ _interop_require_default(require("postcss-load-config/src/options" // Little bit scary, looking at private/internal API
-));
-const _processTailwindFeatures = /*#__PURE__*/ _interop_require_default(require("../../processTailwindFeatures"));
-const _deps = require("./deps");
-const _utils = require("./utils");
-const _sharedState = require("../../lib/sharedState");
-const _resolveConfig = /*#__PURE__*/ _interop_require_default(require("../../../resolveConfig.js"));
-const _content = require("../../lib/content.js");
-const _watching = require("./watching.js");
-const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
-const _findAtConfigPath = require("../../lib/findAtConfigPath.js");
-const _log = /*#__PURE__*/ _interop_require_default(require("../../util/log"));
-const _loadconfig = require("../../lib/load-config");
-const _getModuleDependencies = /*#__PURE__*/ _interop_require_default(require("../../lib/getModuleDependencies"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/**
- *
- * @param {string} [customPostCssPath ]
- * @returns
- */ async function loadPostCssPlugins(customPostCssPath) {
-    let config = customPostCssPath ? await (async ()=>{
-        let file = _path.default.resolve(customPostCssPath);
-        // Implementation, see: https://unpkg.com/browse/postcss-load-config@3.1.0/src/index.js
-        // @ts-ignore
-        let { config ={}  } = await (0, _lilconfig.lilconfig)("postcss").load(file);
-        if (typeof config === "function") {
-            config = config();
-        } else {
-            config = Object.assign({}, config);
-        }
-        if (!config.plugins) {
-            config.plugins = [];
-        }
-        return {
-            file,
-            plugins: (0, _plugins.default)(config, file),
-            options: (0, _options.default)(config, file)
-        };
-    })() : await (0, _postcssloadconfig.default)();
-    let configPlugins = config.plugins;
-    let configPluginTailwindIdx = configPlugins.findIndex((plugin)=>{
-        if (typeof plugin === "function" && plugin.name === "tailwindcss") {
-            return true;
-        }
-        if (typeof plugin === "object" && plugin !== null && plugin.postcssPlugin === "tailwindcss") {
-            return true;
-        }
-        return false;
-    });
-    let beforePlugins = configPluginTailwindIdx === -1 ? [] : configPlugins.slice(0, configPluginTailwindIdx);
-    let afterPlugins = configPluginTailwindIdx === -1 ? configPlugins : configPlugins.slice(configPluginTailwindIdx + 1);
-    return [
-        beforePlugins,
-        afterPlugins,
-        config.options
-    ];
-}
-function loadBuiltinPostcssPlugins() {
-    let postcss = (0, _deps.loadPostcss)();
-    let IMPORT_COMMENT = "__TAILWIND_RESTORE_IMPORT__: ";
-    return [
-        [
-            (root)=>{
-                root.walkAtRules("import", (rule)=>{
-                    if (rule.params.slice(1).startsWith("tailwindcss/")) {
-                        rule.after(postcss.comment({
-                            text: IMPORT_COMMENT + rule.params
-                        }));
-                        rule.remove();
-                    }
-                });
-            },
-            (0, _deps.loadPostcssImport)(),
-            (root)=>{
-                root.walkComments((rule)=>{
-                    if (rule.text.startsWith(IMPORT_COMMENT)) {
-                        rule.after(postcss.atRule({
-                            name: "import",
-                            params: rule.text.replace(IMPORT_COMMENT, "")
-                        }));
-                        rule.remove();
-                    }
-                });
-            }
-        ],
-        [],
-        {}
-    ];
-}
-let state = {
-    /** @type {any} */ context: null,
-    /** @type {ReturnType<typeof createWatcher> | null} */ watcher: null,
-    /** @type {{content: string, extension: string}[]} */ changedContent: [],
-    /** @type {ReturnType<typeof load> | null} */ configBag: null,
-    contextDependencies: new Set(),
-    /** @type {import('../../lib/content.js').ContentPath[]} */ contentPaths: [],
-    refreshContentPaths () {
-        var _this_context;
-        this.contentPaths = (0, _content.parseCandidateFiles)(this.context, (_this_context = this.context) === null || _this_context === void 0 ? void 0 : _this_context.tailwindConfig);
-    },
-    get config () {
-        return this.context.tailwindConfig;
-    },
-    get contentPatterns () {
-        return {
-            all: this.contentPaths.map((contentPath)=>contentPath.pattern),
-            dynamic: this.contentPaths.filter((contentPath)=>contentPath.glob !== undefined).map((contentPath)=>contentPath.pattern)
-        };
-    },
-    loadConfig (configPath, content) {
-        if (this.watcher && configPath) {
-            this.refreshConfigDependencies();
-        }
-        let config = (0, _loadconfig.loadConfig)(configPath);
-        let dependencies = (0, _getModuleDependencies.default)(configPath);
-        this.configBag = {
-            config,
-            dependencies,
-            dispose () {
-                for (let file of dependencies){
-                    delete require.cache[require.resolve(file)];
-                }
-            }
-        };
-        // @ts-ignore
-        this.configBag.config = (0, _resolveConfig.default)(this.configBag.config, {
-            content: {
-                files: []
-            }
-        });
-        // Override content files if `--content` has been passed explicitly
-        if ((content === null || content === void 0 ? void 0 : content.length) > 0) {
-            this.configBag.config.content.files = content;
-        }
-        return this.configBag.config;
-    },
-    refreshConfigDependencies () {
-        var _this_configBag;
-        _sharedState.env.DEBUG && console.time("Module dependencies");
-        (_this_configBag = this.configBag) === null || _this_configBag === void 0 ? void 0 : _this_configBag.dispose();
-        _sharedState.env.DEBUG && console.timeEnd("Module dependencies");
-    },
-    readContentPaths () {
-        let content = [];
-        // Resolve globs from the content config
-        // TODO: When we make the postcss plugin async-capable this can become async
-        let files = _fastglob.default.sync(this.contentPatterns.all);
-        for (let file of files){
-            if (false) {
-                content.push({
-                    file,
-                    extension: _path.default.extname(file).slice(1)
-                });
-            } else {
-                content.push({
-                    content: _fs.default.readFileSync(_path.default.resolve(file), "utf8"),
-                    extension: _path.default.extname(file).slice(1)
-                });
-            }
-        }
-        // Resolve raw content in the tailwind config
-        let rawContent = this.config.content.files.filter((file)=>{
-            return file !== null && typeof file === "object";
-        });
-        for (let { raw: htmlContent , extension ="html"  } of rawContent){
-            content.push({
-                content: htmlContent,
-                extension
-            });
-        }
-        return content;
-    },
-    getContext ({ createContext , cliConfigPath , root , result , content  }) {
-        _sharedState.env.DEBUG && console.time("Searching for config");
-        var _findAtConfigPath1;
-        let configPath = (_findAtConfigPath1 = (0, _findAtConfigPath.findAtConfigPath)(root, result)) !== null && _findAtConfigPath1 !== void 0 ? _findAtConfigPath1 : cliConfigPath;
-        _sharedState.env.DEBUG && console.timeEnd("Searching for config");
-        if (this.context) {
-            this.context.changedContent = this.changedContent.splice(0);
-            return this.context;
-        }
-        _sharedState.env.DEBUG && console.time("Loading config");
-        let config = this.loadConfig(configPath, content);
-        _sharedState.env.DEBUG && console.timeEnd("Loading config");
-        _sharedState.env.DEBUG && console.time("Creating context");
-        this.context = createContext(config, []);
-        Object.assign(this.context, {
-            userConfigPath: configPath
-        });
-        _sharedState.env.DEBUG && console.timeEnd("Creating context");
-        _sharedState.env.DEBUG && console.time("Resolving content paths");
-        this.refreshContentPaths();
-        _sharedState.env.DEBUG && console.timeEnd("Resolving content paths");
-        if (this.watcher) {
-            _sharedState.env.DEBUG && console.time("Watch new files");
-            this.watcher.refreshWatchedFiles();
-            _sharedState.env.DEBUG && console.timeEnd("Watch new files");
-        }
-        for (let file of this.readContentPaths()){
-            this.context.changedContent.push(file);
-        }
-        return this.context;
-    }
-};
-async function createProcessor(args, cliConfigPath) {
-    var _args_content;
-    let postcss = (0, _deps.loadPostcss)();
-    let input = args["--input"];
-    let output = args["--output"];
-    let includePostCss = args["--postcss"];
-    let customPostCssPath = typeof args["--postcss"] === "string" ? args["--postcss"] : undefined;
-    let [beforePlugins, afterPlugins, postcssOptions] = includePostCss ? await loadPostCssPlugins(customPostCssPath) : loadBuiltinPostcssPlugins();
-    if (args["--purge"]) {
-        _log.default.warn("purge-flag-deprecated", [
-            "The `--purge` flag has been deprecated.",
-            "Please use `--content` instead."
-        ]);
-        if (!args["--content"]) {
-            args["--content"] = args["--purge"];
-        }
-    }
-    var _args_content_split;
-    let content = (_args_content_split = (_args_content = args["--content"]) === null || _args_content === void 0 ? void 0 : _args_content.split(/(?<!{[^}]+),/)) !== null && _args_content_split !== void 0 ? _args_content_split : [];
-    let tailwindPlugin = ()=>{
-        return {
-            postcssPlugin: "tailwindcss",
-            async Once (root, { result  }) {
-                _sharedState.env.DEBUG && console.time("Compiling CSS");
-                await (0, _processTailwindFeatures.default)(({ createContext  })=>{
-                    console.error();
-                    console.error("Rebuilding...");
-                    return ()=>{
-                        return state.getContext({
-                            createContext,
-                            cliConfigPath,
-                            root,
-                            result,
-                            content
-                        });
-                    };
-                })(root, result);
-                _sharedState.env.DEBUG && console.timeEnd("Compiling CSS");
-            }
-        };
-    };
-    tailwindPlugin.postcss = true;
-    let plugins = [
-        ...beforePlugins,
-        tailwindPlugin,
-        !args["--minify"] && _utils.formatNodes,
-        ...afterPlugins,
-        !args["--no-autoprefixer"] && (0, _deps.loadAutoprefixer)(),
-        args["--minify"] && (0, _deps.loadCssNano)()
-    ].filter(Boolean);
-    /** @type {import('postcss').Processor} */ // @ts-ignore
-    let processor = postcss(plugins);
-    async function readInput() {
-        // Piping in data, let's drain the stdin
-        if (input === "-") {
-            return (0, _utils.drainStdin)();
-        }
-        // Input file has been provided
-        if (input) {
-            return _fs.default.promises.readFile(_path.default.resolve(input), "utf8");
-        }
-        // No input file provided, fallback to default atrules
-        return "@tailwind base; @tailwind components; @tailwind utilities";
-    }
-    async function build() {
-        let start = process.hrtime.bigint();
-        return readInput().then((css)=>processor.process(css, {
-                ...postcssOptions,
-                from: input,
-                to: output
-            })).then((result)=>{
-            if (!state.watcher) {
-                return result;
-            }
-            _sharedState.env.DEBUG && console.time("Recording PostCSS dependencies");
-            for (let message of result.messages){
-                if (message.type === "dependency") {
-                    state.contextDependencies.add(message.file);
-                }
-            }
-            _sharedState.env.DEBUG && console.timeEnd("Recording PostCSS dependencies");
-            // TODO: This needs to be in a different spot
-            _sharedState.env.DEBUG && console.time("Watch new files");
-            state.watcher.refreshWatchedFiles();
-            _sharedState.env.DEBUG && console.timeEnd("Watch new files");
-            return result;
-        }).then((result)=>{
-            if (!output) {
-                process.stdout.write(result.css);
-                return;
-            }
-            return Promise.all([
-                (0, _utils.outputFile)(result.opts.to, result.css),
-                result.map && (0, _utils.outputFile)(result.opts.to + ".map", result.map.toString())
-            ]);
-        }).then(()=>{
-            let end = process.hrtime.bigint();
-            console.error();
-            console.error("Done in", (end - start) / BigInt(1e6) + "ms.");
-        }).then(()=>{}, (err)=>{
-            // TODO: If an initial build fails we can't easily pick up any PostCSS dependencies
-            // that were collected before the error occurred
-            // The result is not stored on the error so we have to store it externally
-            // and pull the messages off of it here somehow
-            // This results in a less than ideal DX because the watcher will not pick up
-            // changes to imported CSS if one of them caused an error during the initial build
-            // If you fix it and then save the main CSS file so there's no error
-            // The watcher will start watching the imported CSS files and will be
-            // resilient to future errors.
-            if (state.watcher) {
-                console.error(err);
-            } else {
-                return Promise.reject(err);
-            }
-        });
-    }
-    /**
-   * @param {{file: string, content(): Promise<string>, extension: string}[]} changes
-   */ async function parseChanges(changes) {
-        return Promise.all(changes.map(async (change)=>({
-                content: await change.content(),
-                extension: change.extension
-            })));
-    }
-    if (input !== undefined && input !== "-") {
-        state.contextDependencies.add(_path.default.resolve(input));
-    }
-    return {
-        build,
-        watch: async ()=>{
-            state.watcher = (0, _watching.createWatcher)(args, {
-                state,
-                /**
-         * @param {{file: string, content(): Promise<string>, extension: string}[]} changes
-         */ async rebuild (changes) {
-                    let needsNewContext = changes.some((change)=>{
-                        var _state_configBag;
-                        return ((_state_configBag = state.configBag) === null || _state_configBag === void 0 ? void 0 : _state_configBag.dependencies.has(change.file)) || state.contextDependencies.has(change.file);
-                    });
-                    if (needsNewContext) {
-                        state.context = null;
-                    } else {
-                        for (let change of (await parseChanges(changes))){
-                            state.changedContent.push(change);
-                        }
-                    }
-                    return build();
-                }
-            });
-            await build();
-        }
-    };
-}

package/lib/cli/build/utils.js

@@ -1,88 +0,0 @@
-// @ts-check
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    indentRecursive: function() {
-        return indentRecursive;
-    },
-    formatNodes: function() {
-        return formatNodes;
-    },
-    readFileWithRetries: function() {
-        return readFileWithRetries;
-    },
-    drainStdin: function() {
-        return drainStdin;
-    },
-    outputFile: function() {
-        return outputFile;
-    }
-});
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function indentRecursive(node, indent = 0) {
-    node.each && node.each((child, i)=>{
-        if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) {
-            child.raws.before = `\n${node.type !== "rule" && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`;
-        }
-        child.raws.after = `\n${"  ".repeat(indent)}`;
-        indentRecursive(child, indent + 1);
-    });
-}
-function formatNodes(root) {
-    indentRecursive(root);
-    if (root.first) {
-        root.first.raws.before = "";
-    }
-}
-async function readFileWithRetries(path, tries = 5) {
-    for(let n = 0; n <= tries; n++){
-        try {
-            return await _fs.default.promises.readFile(path, "utf8");
-        } catch (err) {
-            if (n !== tries) {
-                if (err.code === "ENOENT" || err.code === "EBUSY") {
-                    await new Promise((resolve)=>setTimeout(resolve, 10));
-                    continue;
-                }
-            }
-            throw err;
-        }
-    }
-}
-function drainStdin() {
-    return new Promise((resolve, reject)=>{
-        let result = "";
-        process.stdin.on("data", (chunk)=>{
-            result += chunk;
-        });
-        process.stdin.on("end", ()=>resolve(result));
-        process.stdin.on("error", (err)=>reject(err));
-    });
-}
-async function outputFile(file, newContents) {
-    try {
-        let currentContents = await _fs.default.promises.readFile(file, "utf8");
-        if (currentContents === newContents) {
-            return; // Skip writing the file
-        }
-    } catch  {}
-    // Write the file
-    await _fs.default.promises.mkdir(_path.default.dirname(file), {
-        recursive: true
-    });
-    await _fs.default.promises.writeFile(file, newContents, "utf8");
-}

package/lib/cli/build/watching.js

@@ -1,182 +0,0 @@
-// @ts-check
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createWatcher", {
-    enumerable: true,
-    get: function() {
-        return createWatcher;
-    }
-});
-const _chokidar = /*#__PURE__*/ _interop_require_default(require("chokidar"));
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _micromatch = /*#__PURE__*/ _interop_require_default(require("micromatch"));
-const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _utils = require("./utils.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function createWatcher(args, { state , rebuild  }) {
-    let shouldPoll = args["--poll"];
-    let shouldCoalesceWriteEvents = shouldPoll || process.platform === "win32";
-    // Polling interval in milliseconds
-    // Used only when polling or coalescing add/change events on Windows
-    let pollInterval = 10;
-    let watcher = _chokidar.default.watch([], {
-        // Force checking for atomic writes in all situations
-        // This causes chokidar to wait up to 100ms for a file to re-added after it's been unlinked
-        // This only works when watching directories though
-        atomic: true,
-        usePolling: shouldPoll,
-        interval: shouldPoll ? pollInterval : undefined,
-        ignoreInitial: true,
-        awaitWriteFinish: shouldCoalesceWriteEvents ? {
-            stabilityThreshold: 50,
-            pollInterval: pollInterval
-        } : false
-    });
-    // A queue of rebuilds, file reads, etc… to run
-    let chain = Promise.resolve();
-    /**
-   * A list of files that have been changed since the last rebuild
-   *
-   * @type {{file: string, content: () => Promise<string>, extension: string}[]}
-   */ let changedContent = [];
-    /**
-   * A list of files for which a rebuild has already been queued.
-   * This is used to prevent duplicate rebuilds when multiple events are fired for the same file.
-   * The rebuilt file is cleared from this list when it's associated rebuild has _started_
-   * This is because if the file is changed during a rebuild it won't trigger a new rebuild which it should
-   **/ let pendingRebuilds = new Set();
-    let _timer;
-    let _reject;
-    /**
-   * Rebuilds the changed files and resolves when the rebuild is
-   * complete regardless of whether it was successful or not
-   */ async function rebuildAndContinue() {
-        let changes = changedContent.splice(0);
-        // There are no changes to rebuild so we can just do nothing
-        if (changes.length === 0) {
-            return Promise.resolve();
-        }
-        // Clear all pending rebuilds for the about-to-be-built files
-        changes.forEach((change)=>pendingRebuilds.delete(change.file));
-        // Resolve the promise even when the rebuild fails
-        return rebuild(changes).then(()=>{}, (e)=>{
-            console.error(e.toString());
-        });
-    }
-    /**
-   *
-   * @param {*} file
-   * @param {(() => Promise<string>) | null} content
-   * @param {boolean} skipPendingCheck
-   * @returns {Promise<void>}
-   */ function recordChangedFile(file, content = null, skipPendingCheck = false) {
-        file = _path.default.resolve(file);
-        // Applications like Vim/Neovim fire both rename and change events in succession for atomic writes
-        // In that case rebuild has already been queued by rename, so can be skipped in change
-        if (pendingRebuilds.has(file) && !skipPendingCheck) {
-            return Promise.resolve();
-        }
-        // Mark that a rebuild of this file is going to happen
-        // It MUST happen synchronously before the rebuild is queued for this to be effective
-        pendingRebuilds.add(file);
-        changedContent.push({
-            file,
-            content: content !== null && content !== void 0 ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
-            extension: _path.default.extname(file).slice(1)
-        });
-        if (_timer) {
-            clearTimeout(_timer);
-            _reject();
-        }
-        // If a rebuild is already in progress we don't want to start another one until the 10ms timer has expired
-        chain = chain.then(()=>new Promise((resolve, reject)=>{
-                _timer = setTimeout(resolve, 10);
-                _reject = reject;
-            }));
-        // Resolves once this file has been rebuilt (or the rebuild for this file has failed)
-        // This queues as many rebuilds as there are changed files
-        // But those rebuilds happen after some delay
-        // And will immediately resolve if there are no changes
-        chain = chain.then(rebuildAndContinue, rebuildAndContinue);
-        return chain;
-    }
-    watcher.on("change", (file)=>recordChangedFile(file));
-    watcher.on("add", (file)=>recordChangedFile(file));
-    // Restore watching any files that are "removed"
-    // This can happen when a file is pseudo-atomically replaced (a copy is created, overwritten, the old one is unlinked, and the new one is renamed)
-    // TODO: An an optimization we should allow removal when the config changes
-    watcher.on("unlink", (file)=>{
-        file = (0, _normalizepath.default)(file);
-        // Only re-add the file if it's not covered by a dynamic pattern
-        if (!_micromatch.default.some([
-            file
-        ], state.contentPatterns.dynamic)) {
-            watcher.add(file);
-        }
-    });
-    // Some applications such as Visual Studio (but not VS Code)
-    // will only fire a rename event for atomic writes and not a change event
-    // This is very likely a chokidar bug but it's one we need to work around
-    // We treat this as a change event and rebuild the CSS
-    watcher.on("raw", (evt, filePath, meta)=>{
-        if (evt !== "rename" || filePath === null) {
-            return;
-        }
-        let watchedPath = meta.watchedPath;
-        // Watched path might be the file itself
-        // Or the directory it is in
-        filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath);
-        // Skip this event since the files it is for does not match any of the registered content globs
-        if (!_micromatch.default.some([
-            filePath
-        ], state.contentPatterns.all)) {
-            return;
-        }
-        // Skip since we've already queued a rebuild for this file that hasn't happened yet
-        if (pendingRebuilds.has(filePath)) {
-            return;
-        }
-        // We'll go ahead and add the file to the pending rebuilds list here
-        // It'll be removed when the rebuild starts unless the read fails
-        // which will be taken care of as well
-        pendingRebuilds.add(filePath);
-        async function enqueue() {
-            try {
-                // We need to read the file as early as possible outside of the chain
-                // because it may be gone by the time we get to it. doing the read
-                // immediately increases the chance that the file is still there
-                let content = await (0, _utils.readFileWithRetries)(_path.default.resolve(filePath));
-                if (content === undefined) {
-                    return;
-                }
-                // This will push the rebuild onto the chain
-                // We MUST skip the rebuild check here otherwise the rebuild will never happen on Linux
-                // This is because the order of events and timing is different on Linux
-                // @ts-ignore: TypeScript isn't picking up that content is a string here
-                await recordChangedFile(filePath, ()=>content, true);
-            } catch  {
-            // If reading the file fails, it's was probably a deleted temporary file
-            // So we can ignore it and no rebuild is needed
-            }
-        }
-        enqueue().then(()=>{
-            // If the file read fails we still need to make sure the file isn't stuck in the pending rebuilds list
-            pendingRebuilds.delete(filePath);
-        });
-    });
-    return {
-        fswatcher: watcher,
-        refreshWatchedFiles () {
-            watcher.add(Array.from(state.contextDependencies));
-            watcher.add(Array.from(state.configBag.dependencies));
-            watcher.add(state.contentPatterns.all);
-        }
-    };
-}