@forsakringskassan/docs-generator 2.22.0 → 2.24.0

package/dist/{vendor-BUiT5f0C.js → vendor-DQQ31U4v.js}

@@ -2,37 +2,39 @@
 
 var node_url = require('node:url');
 var path$1 = require('node:path');
-var require$$0 = require('fs');
+var require$$0$1 = require('fs');
 var fs$2 = require('node:fs');
 var fs$1 = require('node:fs/promises');
 var node_events = require('node:events');
 var Stream = require('node:stream');
 var node_string_decoder = require('node:string_decoder');
-var require$$0$1 = require('@vue/compiler-sfc');
+var require$$0$2 = require('@vue/compiler-sfc');
 var require$$1 = require('typescript');
-var require$$0$2 = require('constants');
-var require$$0$3 = require('stream');
+var require$$0$3 = require('constants');
+var require$$0$4 = require('stream');
 var require$$1$1 = require('util');
 var require$$5 = require('assert');
 var sysPath = require('path');
-var require$$0$4 = require('readline');
+var node_module = require('node:module');
+var require$$0$5 = require('readline');
 var require$$3 = require('events');
 var process$1 = require('node:process');
 var util = require('node:util');
 var node_child_process = require('node:child_process');
 var promises = require('node:stream/promises');
 var promises$1 = require('fs/promises');
-var require$$0$5 = require('os');
+var require$$0$6 = require('os');
 var require$$1$5 = require('http');
 var require$$2$2 = require('https');
 var require$$2 = require('url');
-var require$$0$6 = require('buffer');
+var require$$0$7 = require('buffer');
 var require$$1$2 = require('crypto');
 var require$$1$3 = require('net');
 var require$$2$1 = require('tls');
 var require$$1$4 = require('tty');
-var require$$0$7 = require('querystring');
+var require$$0$8 = require('querystring');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
@@ -1430,7 +1432,7 @@ function normalizeReference (str) {
 // so plugins won't have to depend on them explicitly, which reduces their
 // bundled size (e.g. a browser build).
 //
-const lib$2 = { mdurl, ucmicro };
+const lib$3 = { mdurl, ucmicro };
 
 var utils$3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -1446,7 +1448,7 @@ var utils$3 = /*#__PURE__*/Object.freeze({
   isString: isString$1,
   isValidEntityCode: isValidEntityCode,
   isWhiteSpace: isWhiteSpace,
-  lib: lib$2,
+  lib: lib$3,
   normalizeReference: normalizeReference,
   unescapeAll: unescapeAll,
   unescapeMd: unescapeMd
@@ -13047,12 +13049,12 @@ class Minipass extends node_events.EventEmitter {
     }
 }
 
-const realpathSync = require$$0.realpathSync.native;
+const realpathSync = require$$0$1.realpathSync.native;
 const defaultFS = {
-    lstatSync: require$$0.lstatSync,
-    readdir: require$$0.readdir,
-    readdirSync: require$$0.readdirSync,
-    readlinkSync: require$$0.readlinkSync,
+    lstatSync: require$$0$1.lstatSync,
+    readdir: require$$0$1.readdir,
+    readdirSync: require$$0$1.readdirSync,
+    readlinkSync: require$$0$1.readlinkSync,
     realpathSync,
     promises: {
         lstat: fs$1.lstat,
@@ -16337,7 +16339,7 @@ function requireRegisterTs () {
 	if (hasRequiredRegisterTs) return registerTs;
 	hasRequiredRegisterTs = 1;
 	if (typeof commonjsRequire !== 'undefined') {
-	  require$$0$1.registerTS(() => require$$1);
+	  require$$0$2.registerTS(() => require$$1);
 	}
 	return registerTs;
 }
@@ -20772,6 +20774,487 @@ const closest = (str, arr) => {
     return arr[min_index];
 };
 
+var ciInfo = {};
+
+var require$$0 = [
+	{
+		name: "Agola CI",
+		constant: "AGOLA",
+		env: "AGOLA_GIT_REF",
+		pr: "AGOLA_PULL_REQUEST_ID"
+	},
+	{
+		name: "Appcircle",
+		constant: "APPCIRCLE",
+		env: "AC_APPCIRCLE",
+		pr: {
+			env: "AC_GIT_PR",
+			ne: "false"
+		}
+	},
+	{
+		name: "AppVeyor",
+		constant: "APPVEYOR",
+		env: "APPVEYOR",
+		pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "AWS CodeBuild",
+		constant: "CODEBUILD",
+		env: "CODEBUILD_BUILD_ARN",
+		pr: {
+			env: "CODEBUILD_WEBHOOK_EVENT",
+			any: [
+				"PULL_REQUEST_CREATED",
+				"PULL_REQUEST_UPDATED",
+				"PULL_REQUEST_REOPENED"
+			]
+		}
+	},
+	{
+		name: "Azure Pipelines",
+		constant: "AZURE_PIPELINES",
+		env: "TF_BUILD",
+		pr: {
+			BUILD_REASON: "PullRequest"
+		}
+	},
+	{
+		name: "Bamboo",
+		constant: "BAMBOO",
+		env: "bamboo_planKey"
+	},
+	{
+		name: "Bitbucket Pipelines",
+		constant: "BITBUCKET",
+		env: "BITBUCKET_COMMIT",
+		pr: "BITBUCKET_PR_ID"
+	},
+	{
+		name: "Bitrise",
+		constant: "BITRISE",
+		env: "BITRISE_IO",
+		pr: "BITRISE_PULL_REQUEST"
+	},
+	{
+		name: "Buddy",
+		constant: "BUDDY",
+		env: "BUDDY_WORKSPACE_ID",
+		pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+	},
+	{
+		name: "Buildkite",
+		constant: "BUILDKITE",
+		env: "BUILDKITE",
+		pr: {
+			env: "BUILDKITE_PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "CircleCI",
+		constant: "CIRCLE",
+		env: "CIRCLECI",
+		pr: "CIRCLE_PULL_REQUEST"
+	},
+	{
+		name: "Cirrus CI",
+		constant: "CIRRUS",
+		env: "CIRRUS_CI",
+		pr: "CIRRUS_PR"
+	},
+	{
+		name: "Cloudflare Pages",
+		constant: "CLOUDFLARE_PAGES",
+		env: "CF_PAGES"
+	},
+	{
+		name: "Codefresh",
+		constant: "CODEFRESH",
+		env: "CF_BUILD_ID",
+		pr: {
+			any: [
+				"CF_PULL_REQUEST_NUMBER",
+				"CF_PULL_REQUEST_ID"
+			]
+		}
+	},
+	{
+		name: "Codemagic",
+		constant: "CODEMAGIC",
+		env: "CM_BUILD_ID",
+		pr: "CM_PULL_REQUEST"
+	},
+	{
+		name: "Codeship",
+		constant: "CODESHIP",
+		env: {
+			CI_NAME: "codeship"
+		}
+	},
+	{
+		name: "Drone",
+		constant: "DRONE",
+		env: "DRONE",
+		pr: {
+			DRONE_BUILD_EVENT: "pull_request"
+		}
+	},
+	{
+		name: "dsari",
+		constant: "DSARI",
+		env: "DSARI"
+	},
+	{
+		name: "Earthly",
+		constant: "EARTHLY",
+		env: "EARTHLY_CI"
+	},
+	{
+		name: "Expo Application Services",
+		constant: "EAS",
+		env: "EAS_BUILD"
+	},
+	{
+		name: "Gerrit",
+		constant: "GERRIT",
+		env: "GERRIT_PROJECT"
+	},
+	{
+		name: "Gitea Actions",
+		constant: "GITEA_ACTIONS",
+		env: "GITEA_ACTIONS"
+	},
+	{
+		name: "GitHub Actions",
+		constant: "GITHUB_ACTIONS",
+		env: "GITHUB_ACTIONS",
+		pr: {
+			GITHUB_EVENT_NAME: "pull_request"
+		}
+	},
+	{
+		name: "GitLab CI",
+		constant: "GITLAB",
+		env: "GITLAB_CI",
+		pr: "CI_MERGE_REQUEST_ID"
+	},
+	{
+		name: "GoCD",
+		constant: "GOCD",
+		env: "GO_PIPELINE_LABEL"
+	},
+	{
+		name: "Google Cloud Build",
+		constant: "GOOGLE_CLOUD_BUILD",
+		env: "BUILDER_OUTPUT"
+	},
+	{
+		name: "Harness CI",
+		constant: "HARNESS",
+		env: "HARNESS_BUILD_ID"
+	},
+	{
+		name: "Heroku",
+		constant: "HEROKU",
+		env: {
+			env: "NODE",
+			includes: "/app/.heroku/node/bin/node"
+		}
+	},
+	{
+		name: "Hudson",
+		constant: "HUDSON",
+		env: "HUDSON_URL"
+	},
+	{
+		name: "Jenkins",
+		constant: "JENKINS",
+		env: [
+			"JENKINS_URL",
+			"BUILD_ID"
+		],
+		pr: {
+			any: [
+				"ghprbPullId",
+				"CHANGE_ID"
+			]
+		}
+	},
+	{
+		name: "LayerCI",
+		constant: "LAYERCI",
+		env: "LAYERCI",
+		pr: "LAYERCI_PULL_REQUEST"
+	},
+	{
+		name: "Magnum CI",
+		constant: "MAGNUM",
+		env: "MAGNUM"
+	},
+	{
+		name: "Netlify CI",
+		constant: "NETLIFY",
+		env: "NETLIFY",
+		pr: {
+			env: "PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "Nevercode",
+		constant: "NEVERCODE",
+		env: "NEVERCODE",
+		pr: {
+			env: "NEVERCODE_PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "Prow",
+		constant: "PROW",
+		env: "PROW_JOB_ID"
+	},
+	{
+		name: "ReleaseHub",
+		constant: "RELEASEHUB",
+		env: "RELEASE_BUILD_ID"
+	},
+	{
+		name: "Render",
+		constant: "RENDER",
+		env: "RENDER",
+		pr: {
+			IS_PULL_REQUEST: "true"
+		}
+	},
+	{
+		name: "Sail CI",
+		constant: "SAIL",
+		env: "SAILCI",
+		pr: "SAIL_PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Screwdriver",
+		constant: "SCREWDRIVER",
+		env: "SCREWDRIVER",
+		pr: {
+			env: "SD_PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "Semaphore",
+		constant: "SEMAPHORE",
+		env: "SEMAPHORE",
+		pr: "PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Sourcehut",
+		constant: "SOURCEHUT",
+		env: {
+			CI_NAME: "sourcehut"
+		}
+	},
+	{
+		name: "Strider CD",
+		constant: "STRIDER",
+		env: "STRIDER"
+	},
+	{
+		name: "TaskCluster",
+		constant: "TASKCLUSTER",
+		env: [
+			"TASK_ID",
+			"RUN_ID"
+		]
+	},
+	{
+		name: "TeamCity",
+		constant: "TEAMCITY",
+		env: "TEAMCITY_VERSION"
+	},
+	{
+		name: "Travis CI",
+		constant: "TRAVIS",
+		env: "TRAVIS",
+		pr: {
+			env: "TRAVIS_PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "Vela",
+		constant: "VELA",
+		env: "VELA",
+		pr: {
+			VELA_PULL_REQUEST: "1"
+		}
+	},
+	{
+		name: "Vercel",
+		constant: "VERCEL",
+		env: {
+			any: [
+				"NOW_BUILDER",
+				"VERCEL"
+			]
+		},
+		pr: "VERCEL_GIT_PULL_REQUEST_ID"
+	},
+	{
+		name: "Visual Studio App Center",
+		constant: "APPCENTER",
+		env: "APPCENTER_BUILD_ID"
+	},
+	{
+		name: "Woodpecker",
+		constant: "WOODPECKER",
+		env: {
+			CI: "woodpecker"
+		},
+		pr: {
+			CI_BUILD_EVENT: "pull_request"
+		}
+	},
+	{
+		name: "Xcode Cloud",
+		constant: "XCODE_CLOUD",
+		env: "CI_XCODE_PROJECT",
+		pr: "CI_PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Xcode Server",
+		constant: "XCODE_SERVER",
+		env: "XCS"
+	}
+];
+
+var hasRequiredCiInfo;
+
+function requireCiInfo () {
+	if (hasRequiredCiInfo) return ciInfo;
+	hasRequiredCiInfo = 1;
+	(function (exports) {
+
+		const vendors = require$$0;
+
+		const env = process.env;
+
+		// Used for testing only
+		Object.defineProperty(exports, '_vendors', {
+		  value: vendors.map(function (v) {
+		    return v.constant
+		  })
+		});
+
+		exports.name = null;
+		exports.isPR = null;
+		exports.id = null;
+
+		vendors.forEach(function (vendor) {
+		  const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
+		  const isCI = envs.every(function (obj) {
+		    return checkEnv(obj)
+		  });
+
+		  exports[vendor.constant] = isCI;
+
+		  if (!isCI) {
+		    return
+		  }
+
+		  exports.name = vendor.name;
+		  exports.isPR = checkPR(vendor);
+		  exports.id = vendor.constant;
+		});
+
+		exports.isCI = !!(
+		  env.CI !== 'false' && // Bypass all checks if CI env is explicitly set to 'false'
+		  (env.BUILD_ID || // Jenkins, Cloudbees
+		    env.BUILD_NUMBER || // Jenkins, TeamCity
+		    env.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari, Cloudflare Pages
+		    env.CI_APP_ID || // Appflow
+		    env.CI_BUILD_ID || // Appflow
+		    env.CI_BUILD_NUMBER || // Appflow
+		    env.CI_NAME || // Codeship and others
+		    env.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+		    env.RUN_ID || // TaskCluster, dsari
+		    exports.name ||
+		    false)
+		);
+
+		function checkEnv (obj) {
+		  // "env": "CIRRUS"
+		  if (typeof obj === 'string') return !!env[obj]
+
+		  // "env": { "env": "NODE", "includes": "/app/.heroku/node/bin/node" }
+		  if ('env' in obj) {
+		    // Currently there are no other types, uncomment when there are
+		    // if ('includes' in obj) {
+		    return env[obj.env] && env[obj.env].includes(obj.includes)
+		    // }
+		  }
+
+		  if ('any' in obj) {
+		    return obj.any.some(function (k) {
+		      return !!env[k]
+		    })
+		  }
+
+		  return Object.keys(obj).every(function (k) {
+		    return env[k] === obj[k]
+		  })
+		}
+
+		function checkPR (vendor) {
+		  switch (typeof vendor.pr) {
+		    case 'string':
+		      // "pr": "CIRRUS_PR"
+		      return !!env[vendor.pr]
+		    case 'object':
+		      if ('env' in vendor.pr) {
+		        if ('any' in vendor.pr) {
+		          // "pr": { "env": "CODEBUILD_WEBHOOK_EVENT", "any": ["PULL_REQUEST_CREATED", "PULL_REQUEST_UPDATED"] }
+		          return vendor.pr.any.some(function (key) {
+		            return env[vendor.pr.env] === key
+		          })
+		        } else {
+		          // "pr": { "env": "BUILDKITE_PULL_REQUEST", "ne": "false" }
+		          return vendor.pr.env in env && env[vendor.pr.env] !== vendor.pr.ne
+		        }
+		      } else if ('any' in vendor.pr) {
+		        // "pr": { "any": ["ghprbPullId", "CHANGE_ID"] }
+		        return vendor.pr.any.some(function (key) {
+		          return !!env[key]
+		        })
+		      } else {
+		        // "pr": { "DRONE_BUILD_EVENT": "pull_request" }
+		        return checkEnv(vendor.pr)
+		      }
+		    default:
+		      // PR detection not supported for this vendor
+		      return null
+		  }
+		} 
+	} (ciInfo));
+	return ciInfo;
+}
+
+var isCi;
+var hasRequiredIsCi;
+
+function requireIsCi () {
+	if (hasRequiredIsCi) return isCi;
+	hasRequiredIsCi = 1;
+
+	isCi = requireCiInfo().isCI;
+	return isCi;
+}
+
+var isCiExports = requireIsCi();
+var isCI = /*@__PURE__*/getDefaultExportFromCjs(isCiExports);
+
 var fs = {};
 
 var universalify = {};
@@ -20813,7 +21296,7 @@ var hasRequiredPolyfills;
 function requirePolyfills () {
 	if (hasRequiredPolyfills) return polyfills;
 	hasRequiredPolyfills = 1;
-	var constants = require$$0$2;
+	var constants = require$$0$3;
 
 	var origCwd = process.cwd;
 	var cwd = null;
@@ -21177,7 +21660,7 @@ var hasRequiredLegacyStreams;
 function requireLegacyStreams () {
 	if (hasRequiredLegacyStreams) return legacyStreams;
 	hasRequiredLegacyStreams = 1;
-	var Stream = require$$0$3.Stream;
+	var Stream = require$$0$4.Stream;
 
 	legacyStreams = legacy;
 
@@ -21335,7 +21818,7 @@ var hasRequiredGracefulFs;
 function requireGracefulFs () {
 	if (hasRequiredGracefulFs) return gracefulFs;
 	hasRequiredGracefulFs = 1;
-	var fs = require$$0;
+	var fs = require$$0$1;
 	var polyfills = requirePolyfills();
 	var legacy = requireLegacyStreams();
 	var clone = requireClone();
@@ -23146,7 +23629,7 @@ function requireJsonfile$1 () {
 	try {
 	  _fs = requireGracefulFs();
 	} catch (_) {
-	  _fs = require$$0;
+	  _fs = require$$0$1;
 	}
 	const universalify = requireUniversalify();
 	const { stringify, stripBom } = requireUtils$1();
@@ -23500,14 +23983,14 @@ function requireMove () {
 	return move;
 }
 
-var lib$1;
-var hasRequiredLib$1;
+var lib$2;
+var hasRequiredLib$2;
 
-function requireLib$1 () {
-	if (hasRequiredLib$1) return lib$1;
-	hasRequiredLib$1 = 1;
+function requireLib$2 () {
+	if (hasRequiredLib$2) return lib$2;
+	hasRequiredLib$2 = 1;
 
-	lib$1 = {
+	lib$2 = {
 	  // Export promiseified graceful-fs:
 	  ...requireFs(),
 	  // Export extra methods:
@@ -23521,11 +24004,658 @@ function requireLib$1 () {
 	  ...requirePathExists(),
 	  ...requireRemove()
 	};
+	return lib$2;
+}
+
+var libExports$1 = /*@__PURE__*/ requireLib$2();
+var fse = /*@__PURE__*/getDefaultExportFromCjs(libExports$1);
+
+/*!
+ * path-root-regex <https://github.com/jonschlinkert/path-root-regex>
+ *
+ * Copyright (c) 2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var pathRootRegex;
+var hasRequiredPathRootRegex;
+
+function requirePathRootRegex () {
+	if (hasRequiredPathRootRegex) return pathRootRegex;
+	hasRequiredPathRootRegex = 1;
+
+	pathRootRegex = function() {
+	  // Regex is modified from the split device regex in the node.js path module.
+	  return /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?/;
+	};
+	return pathRootRegex;
+}
+
+/*!
+ * path-root <https://github.com/jonschlinkert/path-root>
+ *
+ * Copyright (c) 2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var pathRoot;
+var hasRequiredPathRoot;
+
+function requirePathRoot () {
+	if (hasRequiredPathRoot) return pathRoot;
+	hasRequiredPathRoot = 1;
+
+	var pathRootRegex = requirePathRootRegex();
+
+	pathRoot = function(filepath) {
+	  if (typeof filepath !== 'string') {
+	    throw new TypeError('expected a string');
+	  }
+
+	  var match = pathRootRegex().exec(filepath);
+	  if (match) {
+	    return match[0];
+	  }
+	};
+	return pathRoot;
+}
+
+var rethrowUnlessCode = {};
+
+var hasRequiredRethrowUnlessCode;
+
+function requireRethrowUnlessCode () {
+	if (hasRequiredRethrowUnlessCode) return rethrowUnlessCode;
+	hasRequiredRethrowUnlessCode = 1;
+	Object.defineProperty(rethrowUnlessCode, "__esModule", { value: true });
+	function rethrowUnlessCode$1(maybeError, ...codes) {
+	    if (maybeError !== null && typeof maybeError === 'object') {
+	        const code = maybeError.code;
+	        for (const allowed of codes) {
+	            if (code === allowed) {
+	                return;
+	            }
+	        }
+	    }
+	    throw maybeError;
+	}
+	rethrowUnlessCode.default = rethrowUnlessCode$1;
+	
+	return rethrowUnlessCode;
+}
+
+var shouldPreserveSymlinks;
+var hasRequiredShouldPreserveSymlinks;
+
+function requireShouldPreserveSymlinks () {
+	if (hasRequiredShouldPreserveSymlinks) return shouldPreserveSymlinks;
+	hasRequiredShouldPreserveSymlinks = 1;
+	function includes(array, entry) {
+	    for (let i = 0; i < array.length; i++) {
+	        if (array[i] === entry) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	shouldPreserveSymlinks = function (process) {
+	    return !!process.env.NODE_PRESERVE_SYMLINKS || includes(process.execArgv, '--preserve-symlinks');
+	};
+	
+	return shouldPreserveSymlinks;
+}
+
+var resolvePackagePath_1;
+var hasRequiredResolvePackagePath;
+
+function requireResolvePackagePath () {
+	if (hasRequiredResolvePackagePath) return resolvePackagePath_1;
+	hasRequiredResolvePackagePath = 1;
+	var __importDefault = (resolvePackagePath_1 && resolvePackagePath_1.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	// credit goes to https://github.com/davecombs
+	// extracted in part from: https://github.com/stefanpenner/hash-for-dep/blob/15b2ebcf22024ceb2eb7907f8c412ae40f87b15e/lib/resolve-package-path.js#L1
+	//
+	const fs = require$$0$1;
+	const path = sysPath;
+	const pathRoot = requirePathRoot();
+	const rethrow_unless_code_1 = __importDefault(requireRethrowUnlessCode());
+	/*
+	 * Define a regex that will match against the 'name' value passed into
+	 * resolvePackagePath. The regex corresponds to the following test:
+	 *   Match any of the following 3 alternatives:
+	 *
+	 *  1) dot, then optional second dot, then / or nothing    i.e.  .  ./  ..  ../        OR
+	 *  2) /                                                   i.e.  /                     OR
+	 *  3) (A-Za-z colon - [optional]), then / or \            i.e. optional drive letter + colon, then / or \
+	 *
+	 * Basically, the three choices mean "explicitly relative or absolute path, on either
+	 * Unix/Linux or Windows"
+	 */
+	const ABSOLUTE_OR_RELATIVE_PATH_REGEX = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+	const shouldPreserveSymlinks = requireShouldPreserveSymlinks();
+	const PRESERVE_SYMLINKS = shouldPreserveSymlinks(process);
+	/*
+	 * Resolve the real path for a file. Return null if does not
+	 * exist or is not a file or FIFO, return the real path otherwise.
+	 *
+	 * Cache the result in the passed-in cache for performance,
+	 * keyed on the filePath passed in.
+	 *
+	 * NOTE: Because this is a private method, it does not attempt to normalize
+	 * the path passed in - it assumes the caller has done that.
+	 *
+	 * @private
+	 * @method _getRealFilePath
+	 * @param {Cache} realFilePathCache the Cache object to cache the real (resolved)
+	 * path in, keyed by filePath. See lib/cache.js and lib/cache-group.js
+	 * @param {String} filePath the path to the file of interest (which must have
+	 * been normalized, but not necessarily resolved to a real path).
+	 * @return {String} real path or null
+	 */
+	function _getRealFilePath(realFilePathCache, filePath) {
+	    if (realFilePathCache.has(filePath)) {
+	        return realFilePathCache.get(filePath); // could be null
+	    }
+	    let realPath = null; // null = 'FILE NOT FOUND'
+	    try {
+	        const stat = fs.statSync(filePath);
+	        // I don't know if Node would handle having the filePath actually
+	        // be a FIFO, but as the following is also part of the node-resolution
+	        // algorithm in resolve.sync(), we'll do the same check here.
+	        if (stat.isFile() || stat.isFIFO()) {
+	            if (PRESERVE_SYMLINKS) {
+	                realPath = filePath;
+	            }
+	            else {
+	                realPath = fs.realpathSync(filePath);
+	            }
+	        }
+	    }
+	    catch (e) {
+	        (0, rethrow_unless_code_1.default)(e, 'ENOENT');
+	    }
+	    realFilePathCache.set(filePath, realPath);
+	    return realPath;
+	}
+	/*
+	 * Resolve the real path for a directory, return null if does not
+	 * exist or is not a directory, return the real path otherwise.
+	 *
+	 * @param {Cache} realDirectoryPathCache the Cache object to cache the real (resolved)
+	 * path in, keyed by directoryPath. See lib/cache.js and lib/cache-group.js
+	 * @param {String} directoryPath the path to the directory of interest (which must have
+	 * been normalized, but not necessarily resolved to a real path).
+	 * @return {String} real path or null
+	 */
+	function _getRealDirectoryPath(realDirectoryPathCache, directoryPath) {
+	    if (realDirectoryPathCache.has(directoryPath)) {
+	        return realDirectoryPathCache.get(directoryPath); // could be null
+	    }
+	    let realPath = null;
+	    try {
+	        const stat = fs.statSync(directoryPath);
+	        if (stat.isDirectory()) {
+	            if (PRESERVE_SYMLINKS) {
+	                realPath = directoryPath;
+	            }
+	            else {
+	                realPath = fs.realpathSync(directoryPath);
+	            }
+	        }
+	    }
+	    catch (e) {
+	        (0, rethrow_unless_code_1.default)(e, 'ENOENT', 'ENOTDIR');
+	    }
+	    realDirectoryPathCache.set(directoryPath, realPath);
+	    return realPath;
+	}
+	/*
+	 * Given a package 'name' and starting directory, resolve to a real (existing) file path.
+	 *
+	 * Do it similar to how it is done in resolve.sync() - travel up the directory hierarchy,
+	 * attaching 'node-modules' to each directory and seeing if the directory exists and
+	 * has the relevant 'package.json' file we're searching for. It is *much* faster than
+	 * resolve.sync(), because we don't test that the requested name is a directory.
+	 * This routine assumes that it is only called when we don't already have
+	 * the cached entry.
+	 *
+	 * NOTE: it is valid for 'name' to be an absolute or relative path.
+	 * Because this is an internal routine, we'll require that 'dir' be non-empty
+	 * if this is called, to make things simpler (see resolvePackagePath).
+	 *
+	 * @param realFilePathCache the cache containing the real paths corresponding to
+	 *   various file and directory paths (which may or may not be already resolved).
+	 *
+	 * @param name the 'name' of the module, i.e. x in require(x), but with
+	 *   '/package.json' on the end. It is NOT referring to a directory (so we don't
+	 *   have to do the directory checks that resolve.sync does).
+	 *   NOTE: because this is an internal routine, for speed it does not check
+	 *   that '/package.json' is actually the end of the name.
+	 *
+	 * @param dir the directory (MUST BE non-empty, and valid) to start from, appending the name to the
+	 *   directory and checking that the file exists. Go up the directory hierarchy from there.
+	 *   if name is itself an absolute path,
+	 *
+	 * @result the path to the actual package.json file that's found, or null if not.
+	 */
+	function _findPackagePath(realFilePathCache, name, dir) {
+	    const fsRoot = pathRoot(dir);
+	    let currPath = dir;
+	    while (currPath !== fsRoot) {
+	        // when testing for 'node_modules', need to allow names like NODE_MODULES,
+	        // which can occur with case-insensitive OSes.
+	        let endsWithNodeModules = path.basename(currPath).toLowerCase() === 'node_modules';
+	        let filePath = path.join(currPath, endsWithNodeModules ? '' : 'node_modules', name);
+	        let realPath = _getRealFilePath(realFilePathCache, filePath);
+	        if (realPath) {
+	            return realPath;
+	        }
+	        if (endsWithNodeModules) {
+	            // go up past the ending node_modules directory so the next dirname
+	            // goes up past that (if ending in node_modules, going up just one
+	            // directory below will then add 'node_modules' on the next loop and
+	            // re-process this same node_modules directory.
+	            currPath = path.dirname(currPath);
+	        }
+	        currPath = path.dirname(currPath);
+	    }
+	    return null;
+	}
+	/*
+	 * Resolve the path to the nearest `package.json` from the given initial search
+	 * directory.
+	 *
+	 * @param  {Cache} findUpCache - a cache of memoized results that is
+	 * prioritized to avoid I/O.
+	 *
+	 * @param {string} initialSearchDir - the normalized path to start searching
+	 * from.
+	 *
+	 * @return {string | null} - the deepest directory on the path to root from
+	 * `initialSearchDir` that contains a {{package.json}}, or `null` if no such
+	 * directory exists.
+	 */
+	function _findUpPackagePath(findUpCache, initialSearchDir) {
+	    let previous;
+	    let dir = initialSearchDir;
+	    let maybePackageJsonPath;
+	    let result = null;
+	    do {
+	        if (findUpCache.has(dir)) {
+	            result = findUpCache.get(dir);
+	            break;
+	        }
+	        maybePackageJsonPath = path.join(dir, 'package.json');
+	        if (fs.existsSync(maybePackageJsonPath)) {
+	            result = maybePackageJsonPath;
+	            break;
+	        }
+	        previous = dir;
+	        dir = path.dirname(dir);
+	    } while (dir !== previous);
+	    findUpCache.set(initialSearchDir, result);
+	    return result;
+	}
+	/*
+	 * Resolve the path to a module's package.json file, if it exists. The
+	 * name and dir are as in hashForDep and ModuleEntry.locate.
+	 *
+	 *  @param caches an instance of CacheGroup where information will be cached
+	 *  during processing.
+	 *
+	 *  @param name the 'name' of the module.  The name may also be a path,
+	 *  either relative or absolute. The path must be to a module DIRECTORY, NOT to the
+	 *  package.json file in the directory, as we attach 'package.json' here.
+	 *
+	 *  @param dir (optional) the root directory to run the path resolution from.
+	 *  if dir is not provided, __dirname for this module is used instead.
+	 *
+	 *  @return the realPath corresponding to the module's package.json file, or null
+	 *  if that file is not found or is not a file.
+	 *
+	 * Note: 'name' is expected in the format expected for require(x), i.e., it is
+	 * resolved using the Node path-normalization rules.
+	 */
+	function resolvePackagePath(caches, name, dir) {
+	    if (typeof name !== 'string' || name.length === 0) {
+	        throw new TypeError("resolvePackagePath: 'name' must be a non-zero-length string.");
+	    }
+	    // Perform tests similar to those in resolve.sync().
+	    let basedir = dir || __dirname;
+	    // Ensure that basedir is an absolute path at this point. If it does not refer to
+	    // a real directory, go up the path until a real directory is found, or return an error.
+	    // BUG!: this will never throw an exception, at least on Unix/Linux. If the path is
+	    // relative, path.resolve() will make it absolute by putting the current directory
+	    // before it, so it won't fail. If the path is already absolute, / will always be
+	    // valid, so again it won't fail.
+	    let absoluteStart = path.resolve(basedir);
+	    while (_getRealDirectoryPath(caches.REAL_DIRECTORY_PATH, absoluteStart) === null) {
+	        absoluteStart = path.dirname(absoluteStart);
+	    }
+	    if (!absoluteStart) {
+	        let error = new TypeError("resolvePackagePath: 'dir' or one of the parent directories in its path must refer to a valid directory.");
+	        error.code = 'MODULE_NOT_FOUND';
+	        throw error;
+	    }
+	    if (ABSOLUTE_OR_RELATIVE_PATH_REGEX.test(name)) {
+	        let res = path.resolve(absoluteStart, name);
+	        return _getRealFilePath(caches.REAL_FILE_PATH, path.join(res, 'package.json'));
+	        // XXX Do we need to handle the core(x) case too? Not sure.
+	    }
+	    else {
+	        return _findPackagePath(caches.REAL_FILE_PATH, path.join(name, 'package.json'), absoluteStart);
+	    }
+	}
+	resolvePackagePath._findPackagePath = _findPackagePath;
+	resolvePackagePath._findUpPackagePath = _findUpPackagePath;
+	resolvePackagePath._getRealFilePath = _getRealFilePath;
+	resolvePackagePath._getRealDirectoryPath = _getRealDirectoryPath;
+	resolvePackagePath_1 = resolvePackagePath;
+	
+	return resolvePackagePath_1;
+}
+
+var cache;
+var hasRequiredCache;
+
+function requireCache () {
+	if (hasRequiredCache) return cache;
+	hasRequiredCache = 1;
+	function makeCache() {
+	    // object with no prototype
+	    const cache = Object.create(null);
+	    // force the jit to immediately realize this object is a dictionary. This
+	    // should prevent the JIT from going wastefully one direction (fast mode)
+	    // then going another (dict mode) after
+	    cache['_cache'] = 1;
+	    delete cache['_cache'];
+	    return cache;
+	}
+	cache = class Cache {
+	    constructor() {
+	        this._store = makeCache();
+	    }
+	    set(key, value) {
+	        return (this._store[key] = value);
+	    }
+	    get(key) {
+	        return this._store[key];
+	    }
+	    has(key) {
+	        return key in this._store;
+	    }
+	    delete(key) {
+	        delete this._store[key];
+	    }
+	    get size() {
+	        return Object.keys(this._store).length;
+	    }
+	};
+	
+	return cache;
+}
+
+var cacheGroup;
+var hasRequiredCacheGroup;
+
+function requireCacheGroup () {
+	if (hasRequiredCacheGroup) return cacheGroup;
+	hasRequiredCacheGroup = 1;
+	const Cache = requireCache();
+	cacheGroup = class CacheGroup {
+	    constructor() {
+	        this.MODULE_ENTRY = new Cache();
+	        this.PATH = new Cache();
+	        this.REAL_FILE_PATH = new Cache();
+	        this.REAL_DIRECTORY_PATH = new Cache();
+	        Object.freeze(this);
+	    }
+	};
+	
+	return cacheGroup;
+}
+
+var lib$1;
+var hasRequiredLib$1;
+
+function requireLib$1 () {
+	if (hasRequiredLib$1) return lib$1;
+	hasRequiredLib$1 = 1;
+	var __importDefault = (lib$1 && lib$1.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	const path_1 = __importDefault(sysPath);
+	const resolve_package_path_1 = __importDefault(requireResolvePackagePath());
+	const rethrow_unless_code_1 = __importDefault(requireRethrowUnlessCode());
+	const ALLOWED_ERROR_CODES = [
+	    // resolve package error codes
+	    'MODULE_NOT_FOUND',
+	    // Yarn PnP Error Codes
+	    'UNDECLARED_DEPENDENCY',
+	    'MISSING_PEER_DEPENDENCY',
+	    'MISSING_DEPENDENCY'
+	];
+	const CacheGroup = requireCacheGroup();
+	const Cache = requireCache();
+	const getRealFilePath = resolve_package_path_1.default._getRealFilePath;
+	const getRealDirectoryPath = resolve_package_path_1.default._getRealDirectoryPath;
+	const __findUpPackagePath = resolve_package_path_1.default._findUpPackagePath;
+	let CACHE = new CacheGroup();
+	let FIND_UP_CACHE = new Cache();
+	let pnp;
+	try {
+	    // eslint-disable-next-line node/no-missing-require
+	    pnp = require('pnpapi');
+	}
+	catch (error) {
+	    // not in Yarn PnP; not a problem
+	}
+	/**
+	 * Search each directory in the absolute path `baseDir`, from leaf to root, for
+	 * a `package.json`, and return the first match, or `null` if no `package.json`
+	 * was found.
+	 *
+	 * @public
+	 * @param {string} baseDir - an absolute path in which to search for a `package.json`
+	 * @param {CacheGroup|boolean} [_cache] (optional)
+	 *  * if true: will choose the default global cache
+	 *  * if false: will not cache
+	 *  * if undefined or omitted, will choose the default global cache
+	 *  * otherwise we assume the argument is an external cache of the form provided by resolve-package-path/lib/cache-group.js
+	 *
+	 * @return {string|null} a full path to the resolved package.json if found or null if not
+	 */
+	function _findUpPackagePath(baseDir, _cache) {
+	    let cache;
+	    if (_cache === undefined || _cache === null || _cache === true) {
+	        // if no cache specified, or if cache is true then use the global cache
+	        cache = FIND_UP_CACHE;
+	    }
+	    else if (_cache === false) {
+	        // if cache is explicity false, create a throw-away cache;
+	        cache = new Cache();
+	    }
+	    else {
+	        // otherwise, assume the user has provided an alternative cache for the following form:
+	        // provided by resolve-package-path/lib/cache-group.js
+	        cache = _cache;
+	    }
+	    let absoluteStart = path_1.default.resolve(baseDir);
+	    return __findUpPackagePath(cache, absoluteStart);
+	}
+	function resolvePackagePath(target, baseDir, _cache) {
+	    let cache;
+	    if (_cache === undefined || _cache === null || _cache === true) {
+	        // if no cache specified, or if cache is true then use the global cache
+	        cache = CACHE;
+	    }
+	    else if (_cache === false) {
+	        // if cache is explicity false, create a throw-away cache;
+	        cache = new CacheGroup();
+	    }
+	    else {
+	        // otherwise, assume the user has provided an alternative cache for the following form:
+	        // provided by resolve-package-path/lib/cache-group.js
+	        cache = _cache;
+	    }
+	    if (baseDir.charAt(baseDir.length - 1) !== path_1.default.sep) {
+	        baseDir = `${baseDir}${path_1.default.sep}`;
+	    }
+	    const key = target + '\x00' + baseDir;
+	    let pkgPath;
+	    if (cache.PATH.has(key)) {
+	        pkgPath = cache.PATH.get(key);
+	    }
+	    else {
+	        try {
+	            // the custom `pnp` code here can be removed when yarn 1.13 is the
+	            // current release. This is due to Yarn 1.13 and resolve interoperating
+	            // together seamlessly.
+	            pkgPath = pnp
+	                ? pnp.resolveToUnqualified(target + '/package.json', baseDir)
+	                : (0, resolve_package_path_1.default)(cache, target, baseDir);
+	        }
+	        catch (e) {
+	            (0, rethrow_unless_code_1.default)(e, ...ALLOWED_ERROR_CODES);
+	            pkgPath = null;
+	        }
+	        cache.PATH.set(key, pkgPath);
+	    }
+	    return pkgPath;
+	}
+	resolvePackagePath._resetCache = function () {
+	    CACHE = new CacheGroup();
+	    FIND_UP_CACHE = new Cache();
+	};
+	// eslint-disable-next-line no-redeclare
+	(function (resolvePackagePath) {
+	    resolvePackagePath._FIND_UP_CACHE = FIND_UP_CACHE;
+	    resolvePackagePath.findUpPackagePath = _findUpPackagePath;
+	})(resolvePackagePath || (resolvePackagePath = {}));
+	Object.defineProperty(resolvePackagePath, '_CACHE', {
+	    get: function () {
+	        return CACHE;
+	    },
+	});
+	Object.defineProperty(resolvePackagePath, '_FIND_UP_CACHE', {
+	    get: function () {
+	        return FIND_UP_CACHE;
+	    },
+	});
+	resolvePackagePath.getRealFilePath = function (filePath) {
+	    return getRealFilePath(CACHE.REAL_FILE_PATH, filePath);
+	};
+	resolvePackagePath.getRealDirectoryPath = function (directoryPath) {
+	    return getRealDirectoryPath(CACHE.REAL_DIRECTORY_PATH, directoryPath);
+	};
+	lib$1 = resolvePackagePath;
+	
 	return lib$1;
 }
 
-var libExports = /*@__PURE__*/ requireLib$1();
-var fse = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+var libExports = requireLib$1();
+var resolvePackagePath = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+function e(e,n,r){throw new Error(r?`No known conditions for "${n}" specifier in "${e}" package`:`Missing "${n}" specifier in "${e}" package`)}function n(n,i,o,f){let s,u,l=r(n,o),c=function(e){let n=new Set(["default",...e.conditions||[]]);return e.unsafe||n.add(e.require?"require":"import"),e.unsafe||n.add(e.browser?"browser":"node"),n}(f||{}),a=i[l];if(void 0===a){let e,n,r,t;for(t in i)n&&t.length<n.length||("/"===t[t.length-1]&&l.startsWith(t)?(u=l.substring(t.length),n=t):t.length>1&&(r=t.indexOf("*",1),~r&&(e=RegExp("^"+t.substring(0,r)+"(.*)"+t.substring(1+r)+"$").exec(l),e&&e[1]&&(u=e[1],n=t))));a=i[n];}return a||e(n,l),s=t(a,c),s||e(n,l,1),u&&function(e,n){let r,t=0,i=e.length,o=/[*]/g,f=/[/]$/;for(;t<i;t++)e[t]=o.test(r=e[t])?r.replace(o,n):f.test(r)?r+n:r;}(s,u),s}function r(e,n,r){if(e===n||"."===n)return ".";let t=e+"/",i=t.length,o=n.slice(0,i)===t,f=o?n.slice(i):n;return "#"===f[0]?f:o||!r?"./"===f.slice(0,2)?f:"./"+f:f}function t(e,n,r){if(e){if("string"==typeof e)return r&&r.add(e),[e];let i,o;if(Array.isArray(e)){for(o=r||new Set,i=0;i<e.length;i++)t(e[i],n,o);if(!r&&o.size)return [...o]}else for(i in e)if(n.has(i))return t(e[i],n,r)}}function i(e,n={}){let t,i=0,o=n.browser,f=n.fields||["module","main"],s="string"==typeof o;for(o&&!f.includes("browser")&&(f.unshift("browser"),s&&(o=r(e.name,o,true)));i<f.length;i++)if(t=e[f[i]]){if("string"==typeof t);else {if("object"!=typeof t||"browser"!=f[i])continue;if(s&&(t=t[o],null==t))return o}return "string"==typeof t?"./"+t.replace(/^\.?\//,""):t}}function o(e,r,t){let i,o=e.exports;if(o){if("string"==typeof o)o={".":o};else for(i in o){"."!==i[0]&&(o={".":o});break}return n(e.name,o,r||".",t)}}
+
+// src/importer.js
+
+// src/parsePackageName.js
+var SCOPED_PACKAGE = /^(@[^/]+\/[^@/]+).*?$/;
+var NON_SCOPED_PACKAGE = /^([^@/]+).*?$/;
+function getPackageNameFromPath(input) {
+  const match = SCOPED_PACKAGE.exec(input) || NON_SCOPED_PACKAGE.exec(input);
+  if (!input || !match) {
+    return null;
+  }
+  return match[1];
+}
+
+// src/importer.js
+var { findUpPackagePath } = resolvePackagePath;
+var require2 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vendor-DQQ31U4v.js', document.baseURI).href)));
+var WEBPACK_NODE_MODULE_PREFIX = "~";
+var selfPackageJson = null;
+var selfPackageJsonPath = null;
+var moduleImporter = {
+  findFileUrl(url) {
+    setSelfPackage();
+    let findUrl = url;
+    if (url.startsWith(WEBPACK_NODE_MODULE_PREFIX)) {
+      findUrl = url.substring(1);
+    }
+    const packageName = getPackageNameFromPath(findUrl);
+    const filePath = findUrl.split(packageName)[1];
+    if (!packageName) {
+      return null;
+    }
+    let packageJson = selfPackageJson;
+    let packagePath = selfPackageJsonPath;
+    if (selfPackageJson.name !== packageName) {
+      packagePath = resolvePackagePath(packageName, process.cwd());
+      if (!packagePath) {
+        return null;
+      }
+      packageJson = JSON.parse(
+        fs$2.readFileSync(packagePath, { encoding: "utf-8" })
+      );
+    }
+    const moduleDirectory = path$1.dirname(packagePath);
+    try {
+      const match = o(packageJson, filePath.substring(1), {
+        conditions: ["sass"]
+      });
+      if (match && match.length === 1) {
+        return new URL(
+          node_url.pathToFileURL(path$1.join(moduleDirectory, match[0]))
+        );
+      }
+    } catch {
+    }
+    if (!filePath) {
+      const match = i(packageJson, { fields: ["sass", "main"] });
+      if (match) {
+        return new URL(
+          node_url.pathToFileURL(path$1.join(moduleDirectory, match))
+        );
+      }
+    }
+    const directory = path$1.dirname(filePath);
+    const fileName = path$1.basename(filePath);
+    const search = [
+      `${fileName}.css`,
+      `${fileName}.scss`,
+      `_${fileName}.scss`,
+      `${fileName}`
+    ];
+    for (const variant of search) {
+      try {
+        const moduleName = path$1.posix.join(
+          moduleDirectory,
+          directory,
+          variant
+        );
+        const resolved = require2.resolve(moduleName);
+        return new URL(node_url.pathToFileURL(resolved));
+      } catch (err) {
+        if (err.code !== "MODULE_NOT_FOUND") {
+          throw err;
+        }
+      }
+    }
+    return null;
+  }
+};
+function setSelfPackage() {
+  if (!selfPackageJson) {
+    selfPackageJsonPath = findUpPackagePath(process.cwd());
+    selfPackageJson = JSON.parse(
+      fs$2.readFileSync(selfPackageJsonPath, { encoding: "utf-8" })
+    );
+  }
+}
 
 var eta;
 var hasRequiredEta;
@@ -23614,7 +24744,7 @@ var hasRequiredTerminal;
 function requireTerminal () {
 	if (hasRequiredTerminal) return terminal;
 	hasRequiredTerminal = 1;
-	const _readline = require$$0$4;
+	const _readline = require$$0$5;
 
 	// low-level terminal interactions
 	class Terminal{
@@ -42877,7 +44007,7 @@ const normalizeFilter = (filter) => {
     }
     return emptyFn;
 };
-class ReaddirpStream extends require$$0$3.Readable {
+class ReaddirpStream extends require$$0$4.Readable {
     constructor(options = {}) {
         super({
             objectMode: true,
@@ -43073,7 +44203,7 @@ const isWindows = pl === 'win32';
 const isMacos = pl === 'darwin';
 const isLinux = pl === 'linux';
 const isFreeBSD = pl === 'freebsd';
-const isIBMi = require$$0$5.type() === 'OS400';
+const isIBMi = require$$0$6.type() === 'OS400';
 const EVENTS = {
     ALL: 'all',
     READY: 'ready',
@@ -43184,7 +44314,7 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
         }
     };
     try {
-        return require$$0.watch(path, {
+        return require$$0$1.watch(path, {
             persistent: options.persistent,
         }, handleEvent);
     }
@@ -43306,7 +44436,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
         // doesn't seem worthwhile for the added complexity.
         // listeners = cont.listeners;
         // rawEmitters = cont.rawEmitters;
-        require$$0.unwatchFile(fullPath);
+        require$$0$1.unwatchFile(fullPath);
         cont = undefined;
     }
     if (cont) {
@@ -43321,7 +44451,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
             listeners: listener,
             rawEmitters: rawEmitter,
             options,
-            watcher: require$$0.watchFile(fullPath, options, (curr, prev) => {
+            watcher: require$$0$1.watchFile(fullPath, options, (curr, prev) => {
                 foreach(cont.rawEmitters, (rawEmitter) => {
                     rawEmitter(EV.CHANGE, fullPath, { curr, prev });
                 });
@@ -43341,7 +44471,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
             FsWatchFileInstances.delete(fullPath);
-            require$$0.unwatchFile(fullPath);
+            require$$0$1.unwatchFile(fullPath);
             cont.options = cont.watcher = undefined;
             Object.freeze(cont);
         }
@@ -44278,7 +45408,7 @@ class FSWatcher extends require$$3.EventEmitter {
         const now = new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-            require$$0.stat(fullPath, (err, curStat) => {
+            require$$0$1.stat(fullPath, (err, curStat) => {
                 if (err || !writes.has(path)) {
                     if (err && err.code !== 'ENOENT')
                         awfEmit(err);
@@ -44497,7 +45627,7 @@ function requireSafeBuffer () {
 	hasRequiredSafeBuffer = 1;
 	(function (module, exports) {
 		/* eslint-disable node/no-deprecated-api */
-		var buffer = require$$0$6;
+		var buffer = require$$0$7;
 		var Buffer = buffer.Buffer;
 
 		// alternative to using Object.keys for old browsers
@@ -44615,7 +45745,7 @@ function requireStreams () {
 	**/
 
 
-	var Stream = require$$0$3.Stream,
+	var Stream = require$$0$4.Stream,
 	    util   = require$$1$1;
 
 
@@ -46827,7 +47957,7 @@ function requireProxy () {
 	hasRequiredProxy = 1;
 
 	var Buffer     = requireSafeBuffer().Buffer,
-	    Stream     = require$$0$3.Stream,
+	    Stream     = require$$0$4.Stream,
 	    url        = require$$2,
 	    util       = require$$1$1,
 	    Base       = requireBase(),
@@ -47578,7 +48708,7 @@ function requireApi () {
 	if (hasRequiredApi) return api;
 	hasRequiredApi = 1;
 
-	var Stream      = require$$0$3.Stream,
+	var Stream      = require$$0$4.Stream,
 	    util        = require$$1$1,
 	    driver      = requireDriver(),
 	    EventTarget = requireEvent_target(),
@@ -47883,7 +49013,7 @@ function requireEventsource () {
 	if (hasRequiredEventsource) return eventsource;
 	hasRequiredEventsource = 1;
 
-	var Stream      = require$$0$3.Stream,
+	var Stream      = require$$0$4.Stream,
 	    util        = require$$1$1,
 	    driver      = requireDriver(),
 	    Headers     = requireHeaders(),
@@ -48807,7 +49937,7 @@ var hasRequiredSupportsColor;
 function requireSupportsColor () {
 	if (hasRequiredSupportsColor) return supportsColor_1;
 	hasRequiredSupportsColor = 1;
-	const os = require$$0$5;
+	const os = require$$0$6;
 	const tty = require$$1$4;
 	const hasFlag = requireHasFlag();
 
@@ -49673,7 +50803,7 @@ function requireString_decoder () {
 	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 	// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-	var Buffer = require$$0$6.Buffer;
+	var Buffer = require$$0$7.Buffer;
 
 	var isBufferEncoding = Buffer.isEncoding
 	  || function(encoding) {
@@ -50174,7 +51304,7 @@ var hasRequiredForm;
 function requireForm () {
 	if (hasRequiredForm) return form;
 	hasRequiredForm = 1;
-	var querystringParse = require$$0$7.parse;
+	var querystringParse = require$$0$8.parse;
 
 	var body = requireBody();
 	var parseArguments = requireParseArguments();
@@ -53242,7 +54372,7 @@ function requireServer () {
 
 		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-		var _fs = require$$0;
+		var _fs = require$$0$1;
 
 		var _fs2 = _interopRequireDefault(_fs);
 
@@ -53719,8 +54849,10 @@ exports.fm = fm;
 exports.fse = fse;
 exports.glob = glob;
 exports.globSync = globSync;
+exports.isCI = isCI;
 exports.minimatch = minimatch;
+exports.moduleImporter = moduleImporter;
 exports.spawn = spawn;
 exports.tinylr = tinylr;
 exports.watch = watch$1;
-//# sourceMappingURL=vendor-BUiT5f0C.js.map
+//# sourceMappingURL=vendor-DQQ31U4v.js.map