@forsakringskassan/docs-generator 2.22.0 → 2.23.0

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

@@ -15,6 +15,7 @@ var require$$0$3 = require('stream');
 var require$$1$1 = require('util');
 var require$$5 = require('assert');
 var sysPath = require('path');
+var node_module = require('node:module');
 var require$$0$4 = require('readline');
 var require$$3 = require('events');
 var process$1 = require('node:process');
@@ -33,6 +34,7 @@ var require$$2$1 = require('tls');
 var require$$1$4 = require('tty');
 var require$$0$7 = 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
@@ -23500,14 +23502,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 +23523,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;
+	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-BxO3IPg6.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;
@@ -53720,7 +54369,8 @@ exports.fse = fse;
 exports.glob = glob;
 exports.globSync = globSync;
 exports.minimatch = minimatch;
+exports.moduleImporter = moduleImporter;
 exports.spawn = spawn;
 exports.tinylr = tinylr;
 exports.watch = watch$1;
-//# sourceMappingURL=vendor-BUiT5f0C.js.map
+//# sourceMappingURL=vendor-BxO3IPg6.js.map