@parcel/transformer-stylus 2.16.4 → 3.0.0-alpha.1

package/lib/StylusTransformer.js

@@ -1,330 +1,171 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-function _plugin() {
-  const data = require("@parcel/plugin");
-  _plugin = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@parcel/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _fs() {
-  const data = _interopRequireDefault(require("fs"));
-  _fs = function () {
-    return data;
-  };
-  return data;
-}
-function _stylus() {
-  const data = _interopRequireDefault(require("stylus"));
-  _stylus = function () {
-    return data;
-  };
-  return data;
-}
-function _parser() {
-  const data = _interopRequireDefault(require("stylus/lib/parser"));
-  _parser = function () {
-    return data;
-  };
-  return data;
-}
-function _depsResolver() {
-  const data = _interopRequireDefault(require("stylus/lib/visitor/deps-resolver"));
-  _depsResolver = function () {
-    return data;
-  };
-  return data;
-}
-function _nodes() {
-  const data = _interopRequireDefault(require("stylus/lib/nodes"));
-  _nodes = function () {
-    return data;
-  };
-  return data;
-}
-function _utils2() {
-  const data = _interopRequireDefault(require("stylus/lib/utils"));
-  _utils2 = function () {
-    return data;
-  };
-  return data;
-}
-function _evaluator() {
-  const data = _interopRequireDefault(require("stylus/lib/visitor/evaluator"));
-  _evaluator = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import { Transformer } from '@parcel/plugin';
+import path from 'path';
+import nativeFS from 'fs';
+import stylus from 'stylus';
+import Parser from 'stylus/lib/parser';
+import DepsResolver from 'stylus/lib/visitor/deps-resolver';
+import nodes from 'stylus/lib/nodes/index';
+import * as utils from 'stylus/lib/utils';
+import Evaluator from 'stylus/lib/visitor/evaluator';
 const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
-var _default = exports.default = new (_plugin().Transformer)({
-  async loadConfig({
-    config
-  }) {
-    let configFile = await config.getConfig(['.stylusrc', '.stylusrc.js', '.stylusrc.cjs', '.stylusrc.mjs'], {
-      packageKey: 'stylus'
-    });
-    if (configFile) {
-      // Resolve relative paths from config file
-      if (configFile.contents.paths) {
-        configFile.contents.paths = configFile.contents.paths.map(p => _path().default.resolve(_path().default.dirname(configFile.filePath), p));
-      }
-      return configFile.contents;
+export default new Transformer({
+    async transform ({ asset, resolve, config, options }) {
+        let stylusConfig = {
+            ...config
+        };
+        if (Array.isArray(stylusConfig.paths)) {
+            stylusConfig.paths = stylusConfig.paths.map((p)=>path.join(options.projectRoot, p));
+        }
+        let code = asset.getCode();
+        let style = stylus(code, stylusConfig);
+        style.set('filename', asset.filePath);
+        style.set('include css', true);
+        // Rewrite relative url()s in imported files to be relative to the entry file,
+        // so the CSS transformer resolves them correctly after compilation.
+        style.define('url', stylus.resolver({}));
+        style.set('Evaluator', await createEvaluator(code, asset, resolve, style.options));
+        asset.type = 'css';
+        asset.setCode(style.render());
     }
-  },
-  async transform({
-    asset,
-    resolve,
-    config,
-    options
-  }) {
-    let code = await asset.getCode();
-    let style = (0, _stylus().default)(code, {
-      ...(config ?? {})
-    });
-    style.set('filename', asset.filePath);
-    style.set('include css', true);
-    // Setup a handler for the URL function so we add dependencies for linked assets.
-    style.define('url', node => {
-      let filename = asset.addURLDependency(node.val, {
-        loc: (0, _utils().createDependencyLocation)({
-          line: node.lineno,
-          column: node.column
-        }, node.val)
-      });
-      return new (_stylus().default.nodes.Literal)(`url(${JSON.stringify(filename)})`);
-    });
-    let {
-      resolved: stylusPath
-    } = await options.packageManager.resolve('stylus', __filename);
-    let nativeGlob = await options.packageManager.require('glob', stylusPath);
-    style.set('Evaluator', await createEvaluator(code, asset, resolve, style.options, options, nativeGlob));
-    asset.type = 'css';
-    asset.setCode(style.render());
-    asset.meta.hasDependencies = false;
-    return [asset];
-  }
 });
-function attemptResolve(importedPath, filepath, asset, resolve, deps) {
-  if (deps.has(importedPath)) {
-    return;
-  }
-  if ((0, _utils().isGlob)(importedPath)) {
-    // Invalidate when new files are created that match the glob pattern.
-    let absoluteGlob = _path().default.resolve(_path().default.dirname(filepath), importedPath);
-    asset.invalidateOnFileCreate({
-      glob: absoluteGlob
-    });
-    deps.set(importedPath, (0, _utils().glob)(absoluteGlob, asset.fs, {
-      onlyFiles: true
-    }).then(entries => Promise.all(entries.map(entry => resolve(filepath, './' + _path().default.relative(_path().default.dirname(filepath), entry), {
-      packageConditions: ['stylus', 'style']
-    })))));
-  } else {
-    deps.set(importedPath, resolve(filepath, importedPath, {
-      packageConditions: ['stylus', 'style']
-    }));
-  }
-}
-async function getDependencies(code, filepath, asset, resolve, options, parcelOptions, nativeGlob, seen = new Set(), includeImports = true) {
-  seen.add(filepath);
-  _nodes().default.filename = asset.filePath;
-  let parser = new (_parser().default)(code, options);
-  let ast = parser.parse();
-  let deps = new Map();
-  if (includeImports && options.imports) {
-    for (let importedPath of options.imports) {
-      attemptResolve(importedPath, filepath, asset, resolve, deps);
-    }
-  }
-  class ImportVisitor extends _depsResolver().default {
-    visitImport(imported) {
-      let importedPath = imported.path.first.string;
-      attemptResolve(importedPath, filepath, asset, resolve, deps);
-    }
-  }
-  new ImportVisitor(ast, options).visit(ast);
-
-  // Recursively process depdendencies, and return a map with all resolved paths.
-  let res = new Map();
-  await Promise.all(Array.from(deps.entries()).map(async ([importedPath, resolved]) => {
-    try {
-      resolved = await resolved;
-    } catch (err) {
-      resolved = null;
+function attemptResolve(importedPath, filepath, resolve, deps) {
+    if (deps.has(importedPath)) {
+        return;
     }
-    let found;
-    if (resolved && (!Array.isArray(resolved) || resolved.length > 0)) {
-      found = Array.isArray(resolved) ? resolved : [resolved];
-      res.set(importedPath, resolved);
+    if (/[*[{]/.test(importedPath)) {
+        // Invalidate when new files are created that match the glob pattern.
+        // let absoluteGlob = path.resolve(path.dirname(filepath), importedPath);
+        // asset.invalidateOnFileCreate({glob: absoluteGlob});
+        let cwd = path.dirname(filepath);
+        let entries = nativeFS.globSync(importedPath, {
+            cwd
+        });
+        deps.set(importedPath, Promise.all(entries.filter((e)=>nativeFS.statSync(path.join(cwd, e)).isFile()).map((entry)=>resolveStylesheet(resolve, filepath, './' + entry))));
     } else {
-      // If we couldn't resolve, try the normal stylus resolver.
-      // We just need to do this to keep track of the dependencies - stylus does the real work.
-
-      // support optional .styl
-      let originalPath = importedPath;
-      if (!/\.styl$/i.test(importedPath)) {
-        importedPath += '.styl';
-      }
-
-      // Patch the native FS so we use Parcel's FS, and track files that are
-      // checked so we invalidate the cache when they are created.
-      let restore = patchNativeFS(asset.fs, nativeGlob);
-      let paths = [...new Set((options.paths || []).concat(_path().default.dirname(filepath || '.')))];
-      found = _utils2().default.find(importedPath, paths, filepath);
-      if (!found) {
-        found = _utils2().default.lookupIndex(originalPath, paths, filepath);
-      }
-      for (let invalidation of restore()) {
-        asset.invalidateOnFileCreate(invalidation);
-      }
-      if (!found) {
-        throw new Error('failed to locate file ' + originalPath);
-      }
-    }
-
-    // Recursively process resolved files as well to get nested deps
-    for (let resolved of found) {
-      if (!seen.has(resolved)) {
-        asset.invalidateOnFileChange(resolved);
-        let code = await asset.fs.readFile(resolved, 'utf8');
-        for (let [path, resolvedPath] of await getDependencies(code, resolved, asset, resolve, options, parcelOptions, nativeGlob, seen, false)) {
-          res.set(path, resolvedPath);
-        }
-      }
+        let relative = path.isAbsolute(importedPath) ? './' + path.relative(path.dirname(filepath), importedPath) : importedPath;
+        deps.set(importedPath, resolveStylesheet(resolve, filepath, relative));
     }
-  }));
-  return res;
 }
-async function createEvaluator(code, asset, resolve, options, parcelOptions, nativeGlob) {
-  const deps = await getDependencies(code, asset.filePath, asset, resolve, options, parcelOptions, nativeGlob);
-
-  // This is a custom stylus evaluator that extends stylus with support for the node
-  // require resolution algorithm. It also adds all dependencies to the parcel asset
-  // tree so the file watcher works correctly, etc.
-  class CustomEvaluator extends _evaluator().default {
-    visitImport(imported) {
-      let node = this.visit(imported.path).first;
-      let path = node.string;
-      if (node.name !== 'url' && path && !URL_RE.test(path)) {
-        let resolved = deps.get(path);
-
-        // First try resolving using the node require resolution algorithm.
-        // This allows stylus files in node_modules to be resolved properly.
-        // If we find something, update the AST so stylus gets the absolute path to load later.
-        if (resolved) {
-          if (!Array.isArray(resolved)) {
-            node.string = resolved;
-          } else {
-            // If the import resolves to multiple files (i.e. glob),
-            // replace it with a separate import node for each file
-            return mergeBlocks(resolved.map(resolvedPath => {
-              node.string = resolvedPath;
-              let restore = patchNativeFS(asset.fs, nativeGlob);
-              let res = super.visitImport(imported.clone());
-              restore();
-              return res;
-            }));
-          }
-        }
-      }
-
-      // Patch the native FS so stylus uses Parcel's FS to read the file.
-      let restore = patchNativeFS(asset.fs, nativeGlob);
-
-      // Done. Let stylus do its thing.
-      let res = super.visitImport(imported);
-      restore();
-      return res;
+/** Resolves a stylesheet import to the path of a file, or rejects. */ async function resolveStylesheet(resolve, from, specifier) {
+    let resolved = await resolve(from, specifier, {
+        importType: 'stylesheet',
+        packageConditions: [
+            'stylus',
+            'style'
+        ]
+    });
+    if (resolved?.filePath == null) {
+        throw new Error(`Could not resolve '${specifier}' to a file`);
     }
-  }
-  return CustomEvaluator;
+    return resolved.filePath;
 }
-function patchNativeFS(fs, nativeGlob) {
-  let invalidations = [];
-  let readFileSync = _fs().default.readFileSync;
-  let statSync = _fs().default.statSync;
-
-  // $FlowFixMe
-  _fs().default.readFileSync = (filename, encoding) => {
-    return fs.readFileSync(filename, encoding);
-  };
-
-  // $FlowFixMe
-  _fs().default.statSync = p => {
-    try {
-      return fs.statSync(p);
-    } catch (err) {
-      // Track files that were checked but don't exist so that we watch for their creation.
-      if (!p.includes(`node_modules${_path().default.sep}stylus`)) {
-        invalidations.push({
-          filePath: p
-        });
-      }
-      throw err;
+async function getDependencies(code, filepath, asset, resolve, options, seen = new Set(), includeImports = true) {
+    seen.add(filepath);
+    nodes.filename = asset.filePath;
+    let parser = new Parser(code, options);
+    let ast = parser.parse();
+    let deps = new Map();
+    if (includeImports && options.imports) {
+        for (let importedPath of options.imports){
+            attemptResolve(importedPath, filepath, resolve, deps);
+        }
     }
-  };
-
-  // Patch the `glob` module as well so we use the Parcel FS and track invalidations.
-  let glob = nativeGlob.sync;
-  nativeGlob.sync = p => {
-    let res = (0, _utils().globSync)(p, fs);
-    if (!p.includes(`node_modules${_path().default.sep}stylus`)) {
-      // Sometimes stylus passes file paths with no glob parts to the `glob` module.
-      // We want to avoid treating these as globs for performance.
-      if ((0, _utils().isGlob)(p)) {
-        invalidations.push({
-          glob: p
-        });
-      } else if (res.length === 0) {
-        invalidations.push({
-          filePath: p
-        });
-      }
+    class ImportVisitor extends DepsResolver {
+        visitImport(imported) {
+            let importedPath = imported.path.first.string;
+            attemptResolve(importedPath, filepath, resolve, deps);
+        }
     }
+    new ImportVisitor(ast, options).visit(ast);
+    // Recursively process depdendencies, and return a map with all resolved paths.
+    let res = new Map();
+    await Promise.all(Array.from(deps.entries()).map(async ([importedPath, promise])=>{
+        let resolved;
+        try {
+            resolved = await promise;
+        } catch (err) {
+            resolved = null;
+        }
+        let found;
+        if (resolved && (!Array.isArray(resolved) || resolved.length > 0)) {
+            found = Array.isArray(resolved) ? resolved : [
+                resolved
+            ];
+            res.set(importedPath, resolved);
+        } else {
+            // If we couldn't resolve, try the normal stylus resolver.
+            // We just need to do this to keep track of the dependencies - stylus does the real work.
+            // support optional .styl
+            let originalPath = importedPath;
+            if (!/\.styl$/i.test(importedPath)) {
+                importedPath += '.styl';
+            }
+            let paths = [
+                ...new Set((options.paths || []).concat(path.dirname(filepath || '.')))
+            ];
+            found = utils.find(importedPath, paths, filepath);
+            if (!found) {
+                found = utils.lookupIndex(originalPath, paths, filepath);
+            }
+            if (!found) {
+                throw new Error('failed to locate file ' + originalPath);
+            }
+        }
+        // Recursively process resolved files as well to get nested deps
+        for (let resolved of found){
+            if (!seen.has(resolved)) {
+                let code = nativeFS.readFileSync(resolved, 'utf8');
+                for (let [path, resolvedPath] of (await getDependencies(code, resolved, asset, resolve, options, seen, false))){
+                    res.set(path, resolvedPath);
+                }
+            }
+        }
+    }));
     return res;
-  };
-  return () => {
-    // $FlowFixMe
-    _fs().default.readFileSync = readFileSync;
-    // $FlowFixMe
-    _fs().default.statSync = statSync;
-    nativeGlob.sync = glob;
-    return invalidations;
-  };
 }
-
+async function createEvaluator(code, asset, resolve, options) {
+    const deps = await getDependencies(code, asset.filePath, asset, resolve, options);
+    // This is a custom stylus evaluator that extends stylus with support for the node
+    // require resolution algorithm. It also adds all dependencies to the parcel asset
+    // tree so the file watcher works correctly, etc.
+    class CustomEvaluator extends Evaluator {
+        visitImport(imported) {
+            let node = this.visit(imported.path).first;
+            let path = node.string;
+            if (node.name !== 'url' && path && !URL_RE.test(path)) {
+                let resolved = deps.get(path);
+                // First try resolving using the node require resolution algorithm.
+                // This allows stylus files in node_modules to be resolved properly.
+                // If we find something, update the AST so stylus gets the absolute path to load later.
+                if (resolved) {
+                    if (!Array.isArray(resolved)) {
+                        node.string = resolved;
+                    } else {
+                        // If the import resolves to multiple files (i.e. glob),
+                        // replace it with a separate import node for each file
+                        return mergeBlocks(resolved.map((resolvedPath)=>{
+                            node.string = resolvedPath;
+                            return super.visitImport(imported.clone());
+                        }));
+                    }
+                }
+            }
+            // Done. Let stylus do its thing.
+            return super.visitImport(imported);
+        }
+    }
+    return CustomEvaluator;
+}
 /**
  * Puts the content of all given node blocks into the first one, essentially merging them.
- */
-function mergeBlocks(blocks) {
-  let finalBlock;
-  for (const block of blocks) {
-    if (finalBlock) {
-      // $FlowFixMe - finalBlock is definitely defined
-      block.nodes.forEach(node => finalBlock.push(node));
-    } else {
-      finalBlock = block;
+ */ function mergeBlocks(blocks) {
+    let finalBlock;
+    for (const block of blocks){
+        if (finalBlock) {
+            block.nodes.forEach((node)=>finalBlock.push(node));
+        } else {
+            finalBlock = block;
+        }
     }
-  }
-  return finalBlock;
-}
+    return finalBlock;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/transformer-stylus",
-  "version": "2.16.4",
+  "version": "3.0.0-alpha.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -13,16 +13,21 @@
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
   },
+  "type": "module",
   "main": "lib/StylusTransformer.js",
-  "source": "src/StylusTransformer.js",
+  "files": [
+    "lib"
+  ],
+  "source": "src/StylusTransformer.ts",
   "engines": {
     "node": ">= 16.0.0",
-    "parcel": "^2.16.4"
+    "parcel": "^3.0.0-0"
   },
   "dependencies": {
-    "@parcel/plugin": "2.16.4",
-    "@parcel/utils": "2.16.4",
+    "@parcel/plugin": "^3.0.0-alpha.1",
     "stylus": "^0.63.0"
   },
-  "gitHead": "59484858a1a0bcbb71f74088956bb437a2db6505"
-}
+  "devDependencies": {
+    "@types/stylus": "^0.48.43"
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017-present Devon Govett
-
-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.

package/src/StylusTransformer.js

@@ -1,352 +0,0 @@
-// @flow
-
-import {Transformer} from '@parcel/plugin';
-import {createDependencyLocation, isGlob, glob, globSync} from '@parcel/utils';
-import path from 'path';
-import nativeFS from 'fs';
-import stylus from 'stylus';
-import Parser from 'stylus/lib/parser';
-import DepsResolver from 'stylus/lib/visitor/deps-resolver';
-import nodes from 'stylus/lib/nodes';
-import utils from 'stylus/lib/utils';
-import Evaluator from 'stylus/lib/visitor/evaluator';
-
-const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
-
-export default (new Transformer({
-  async loadConfig({config}) {
-    let configFile = await config.getConfig(
-      ['.stylusrc', '.stylusrc.js', '.stylusrc.cjs', '.stylusrc.mjs'],
-      {
-        packageKey: 'stylus',
-      },
-    );
-
-    if (configFile) {
-      // Resolve relative paths from config file
-      if (configFile.contents.paths) {
-        configFile.contents.paths = configFile.contents.paths.map(p =>
-          path.resolve(path.dirname(configFile.filePath), p),
-        );
-      }
-
-      return configFile.contents;
-    }
-  },
-
-  async transform({asset, resolve, config, options}) {
-    let stylusConfig = config ?? {};
-    let code = await asset.getCode();
-    let style = stylus(code, {...stylusConfig});
-    style.set('filename', asset.filePath);
-    style.set('include css', true);
-    // Setup a handler for the URL function so we add dependencies for linked assets.
-    style.define('url', (node: stylus.nodes.String | stylus.nodes.Literal) => {
-      let filename = asset.addURLDependency(node.val, {
-        loc: createDependencyLocation(
-          {line: node.lineno, column: node.column},
-          node.val,
-        ),
-      });
-      return new stylus.nodes.Literal(`url(${JSON.stringify(filename)})`);
-    });
-
-    let {resolved: stylusPath} = await options.packageManager.resolve(
-      'stylus',
-      __filename,
-    );
-    let nativeGlob = await options.packageManager.require('glob', stylusPath);
-
-    style.set(
-      'Evaluator',
-      await createEvaluator(
-        code,
-        asset,
-        resolve,
-        style.options,
-        options,
-        nativeGlob,
-      ),
-    );
-
-    asset.type = 'css';
-    asset.setCode(style.render());
-    asset.meta.hasDependencies = false;
-    return [asset];
-  },
-}): Transformer);
-
-function attemptResolve(importedPath, filepath, asset, resolve, deps) {
-  if (deps.has(importedPath)) {
-    return;
-  }
-
-  if (isGlob(importedPath)) {
-    // Invalidate when new files are created that match the glob pattern.
-    let absoluteGlob = path.resolve(path.dirname(filepath), importedPath);
-    asset.invalidateOnFileCreate({glob: absoluteGlob});
-
-    deps.set(
-      importedPath,
-      glob(absoluteGlob, asset.fs, {
-        onlyFiles: true,
-      }).then(entries =>
-        Promise.all(
-          entries.map(entry =>
-            resolve(
-              filepath,
-              './' + path.relative(path.dirname(filepath), entry),
-              {
-                packageConditions: ['stylus', 'style'],
-              },
-            ),
-          ),
-        ),
-      ),
-    );
-  } else {
-    deps.set(
-      importedPath,
-      resolve(filepath, importedPath, {
-        packageConditions: ['stylus', 'style'],
-      }),
-    );
-  }
-}
-
-async function getDependencies(
-  code,
-  filepath,
-  asset,
-  resolve,
-  options,
-  parcelOptions,
-  nativeGlob,
-  seen = new Set(),
-  includeImports = true,
-) {
-  seen.add(filepath);
-
-  nodes.filename = asset.filePath;
-
-  let parser = new Parser(code, options);
-  let ast = parser.parse();
-  let deps = new Map();
-
-  if (includeImports && options.imports) {
-    for (let importedPath of options.imports) {
-      attemptResolve(importedPath, filepath, asset, resolve, deps);
-    }
-  }
-
-  class ImportVisitor extends DepsResolver {
-    visitImport(imported) {
-      let importedPath = imported.path.first.string;
-      attemptResolve(importedPath, filepath, asset, resolve, deps);
-    }
-  }
-
-  new ImportVisitor(ast, options).visit(ast);
-
-  // Recursively process depdendencies, and return a map with all resolved paths.
-  let res = new Map();
-  await Promise.all(
-    Array.from(deps.entries()).map(async ([importedPath, resolved]) => {
-      try {
-        resolved = await resolved;
-      } catch (err) {
-        resolved = null;
-      }
-
-      let found;
-      if (resolved && (!Array.isArray(resolved) || resolved.length > 0)) {
-        found = Array.isArray(resolved) ? resolved : [resolved];
-        res.set(importedPath, resolved);
-      } else {
-        // If we couldn't resolve, try the normal stylus resolver.
-        // We just need to do this to keep track of the dependencies - stylus does the real work.
-
-        // support optional .styl
-        let originalPath = importedPath;
-        if (!/\.styl$/i.test(importedPath)) {
-          importedPath += '.styl';
-        }
-
-        // Patch the native FS so we use Parcel's FS, and track files that are
-        // checked so we invalidate the cache when they are created.
-        let restore = patchNativeFS(asset.fs, nativeGlob);
-
-        let paths = [
-          ...new Set(
-            (options.paths || []).concat(path.dirname(filepath || '.')),
-          ),
-        ];
-        found = utils.find(importedPath, paths, filepath);
-        if (!found) {
-          found = utils.lookupIndex(originalPath, paths, filepath);
-        }
-
-        for (let invalidation of restore()) {
-          asset.invalidateOnFileCreate(invalidation);
-        }
-
-        if (!found) {
-          throw new Error('failed to locate file ' + originalPath);
-        }
-      }
-
-      // Recursively process resolved files as well to get nested deps
-      for (let resolved of found) {
-        if (!seen.has(resolved)) {
-          asset.invalidateOnFileChange(resolved);
-
-          let code = await asset.fs.readFile(resolved, 'utf8');
-          for (let [path, resolvedPath] of await getDependencies(
-            code,
-            resolved,
-            asset,
-            resolve,
-            options,
-            parcelOptions,
-            nativeGlob,
-            seen,
-            false,
-          )) {
-            res.set(path, resolvedPath);
-          }
-        }
-      }
-    }),
-  );
-
-  return res;
-}
-
-async function createEvaluator(
-  code,
-  asset,
-  resolve,
-  options,
-  parcelOptions,
-  nativeGlob,
-) {
-  const deps = await getDependencies(
-    code,
-    asset.filePath,
-    asset,
-    resolve,
-    options,
-    parcelOptions,
-    nativeGlob,
-  );
-
-  // This is a custom stylus evaluator that extends stylus with support for the node
-  // require resolution algorithm. It also adds all dependencies to the parcel asset
-  // tree so the file watcher works correctly, etc.
-  class CustomEvaluator extends Evaluator {
-    visitImport(imported) {
-      let node = this.visit(imported.path).first;
-      let path = node.string;
-      if (node.name !== 'url' && path && !URL_RE.test(path)) {
-        let resolved = deps.get(path);
-
-        // First try resolving using the node require resolution algorithm.
-        // This allows stylus files in node_modules to be resolved properly.
-        // If we find something, update the AST so stylus gets the absolute path to load later.
-        if (resolved) {
-          if (!Array.isArray(resolved)) {
-            node.string = resolved;
-          } else {
-            // If the import resolves to multiple files (i.e. glob),
-            // replace it with a separate import node for each file
-            return mergeBlocks(
-              resolved.map(resolvedPath => {
-                node.string = resolvedPath;
-                let restore = patchNativeFS(asset.fs, nativeGlob);
-                let res = super.visitImport(imported.clone());
-                restore();
-                return res;
-              }),
-            );
-          }
-        }
-      }
-
-      // Patch the native FS so stylus uses Parcel's FS to read the file.
-      let restore = patchNativeFS(asset.fs, nativeGlob);
-
-      // Done. Let stylus do its thing.
-      let res = super.visitImport(imported);
-
-      restore();
-      return res;
-    }
-  }
-
-  return CustomEvaluator;
-}
-
-function patchNativeFS(fs, nativeGlob) {
-  let invalidations = [];
-  let readFileSync = nativeFS.readFileSync;
-  let statSync = nativeFS.statSync;
-
-  // $FlowFixMe
-  nativeFS.readFileSync = (filename, encoding) => {
-    return fs.readFileSync(filename, encoding);
-  };
-
-  // $FlowFixMe
-  nativeFS.statSync = p => {
-    try {
-      return fs.statSync(p);
-    } catch (err) {
-      // Track files that were checked but don't exist so that we watch for their creation.
-      if (!p.includes(`node_modules${path.sep}stylus`)) {
-        invalidations.push({filePath: p});
-      }
-      throw err;
-    }
-  };
-
-  // Patch the `glob` module as well so we use the Parcel FS and track invalidations.
-  let glob = nativeGlob.sync;
-  nativeGlob.sync = p => {
-    let res = globSync(p, fs);
-    if (!p.includes(`node_modules${path.sep}stylus`)) {
-      // Sometimes stylus passes file paths with no glob parts to the `glob` module.
-      // We want to avoid treating these as globs for performance.
-      if (isGlob(p)) {
-        invalidations.push({glob: p});
-      } else if (res.length === 0) {
-        invalidations.push({filePath: p});
-      }
-    }
-    return res;
-  };
-
-  return () => {
-    // $FlowFixMe
-    nativeFS.readFileSync = readFileSync;
-    // $FlowFixMe
-    nativeFS.statSync = statSync;
-    nativeGlob.sync = glob;
-    return invalidations;
-  };
-}
-
-/**
- * Puts the content of all given node blocks into the first one, essentially merging them.
- */
-function mergeBlocks(blocks) {
-  let finalBlock;
-  for (const block of blocks) {
-    if (finalBlock) {
-      // $FlowFixMe - finalBlock is definitely defined
-      block.nodes.forEach(node => finalBlock.push(node));
-    } else {
-      finalBlock = block;
-    }
-  }
-  return finalBlock;
-}