@forsakringskassan/docs-generator 2.21.4 → 2.23.0

package/dist/{vendor-CLvDQIrx.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
@@ -10618,6 +10620,7 @@ class LRUCache {
     #max;
     #maxSize;
     #dispose;
+    #onInsert;
     #disposeAfter;
     #fetchMethod;
     #memoMethod;
@@ -10699,6 +10702,7 @@ class LRUCache {
     #hasDispose;
     #hasFetchMethod;
     #hasDisposeAfter;
+    #hasOnInsert;
     /**
      * Do not call this method unless you need to inspect the
      * inner workings of the cache.  If anything returned by this
@@ -10775,6 +10779,12 @@ class LRUCache {
     get dispose() {
         return this.#dispose;
     }
+    /**
+     * {@link LRUCache.OptionsBase.onInsert} (read-only)
+     */
+    get onInsert() {
+        return this.#onInsert;
+    }
     /**
      * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
      */
@@ -10782,7 +10792,7 @@ class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
         if (max !== 0 && !isPosInt(max)) {
             throw new TypeError('max option must be a nonnegative integer');
         }
@@ -10826,6 +10836,9 @@ class LRUCache {
         if (typeof dispose === 'function') {
             this.#dispose = dispose;
         }
+        if (typeof onInsert === 'function') {
+            this.#onInsert = onInsert;
+        }
         if (typeof disposeAfter === 'function') {
             this.#disposeAfter = disposeAfter;
             this.#disposed = [];
@@ -10835,6 +10848,7 @@ class LRUCache {
             this.#disposed = undefined;
         }
         this.#hasDispose = !!this.#dispose;
+        this.#hasOnInsert = !!this.#onInsert;
         this.#hasDisposeAfter = !!this.#disposeAfter;
         this.noDisposeOnSet = !!noDisposeOnSet;
         this.noUpdateTTL = !!noUpdateTTL;
@@ -11402,6 +11416,9 @@ class LRUCache {
             if (status)
                 status.set = 'add';
             noUpdateTTL = false;
+            if (this.#hasOnInsert) {
+                this.#onInsert?.(v, k, 'add');
+            }
         }
         else {
             // update
@@ -11443,6 +11460,9 @@ class LRUCache {
             else if (status) {
                 status.set = 'update';
             }
+            if (this.#hasOnInsert) {
+                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+            }
         }
         if (ttl !== 0 && !this.#ttls) {
             this.#initializeTTLTracking();
@@ -23482,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:
@@ -23503,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;
@@ -51650,6 +52317,7 @@ function requireGetIntrinsic () {
 		'%Error%': $Error,
 		'%eval%': eval, // eslint-disable-line no-eval
 		'%EvalError%': $EvalError,
+		'%Float16Array%': typeof Float16Array === 'undefined' ? undefined$1 : Float16Array,
 		'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
 		'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
 		'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
@@ -51954,10 +52622,11 @@ function requireCallBound () {
 
 	/** @type {import('.')} */
 	callBound = function callBoundIntrinsic(name, allowMissing) {
-		// eslint-disable-next-line no-extra-parens
-		var intrinsic = /** @type {Parameters<typeof callBindBasic>[0][0]} */ (GetIntrinsic(name, !!allowMissing));
+		/* eslint no-extra-parens: 0 */
+
+		var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing));
 		if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
-			return callBindBasic([intrinsic]);
+			return callBindBasic(/** @type {const} */ ([intrinsic]));
 		}
 		return intrinsic;
 	};
@@ -52255,7 +52924,7 @@ function requireUtils () {
 	};
 
 	var arrayToObject = function arrayToObject(source, options) {
-	    var obj = options && options.plainObjects ? Object.create(null) : {};
+	    var obj = options && options.plainObjects ? { __proto__: null } : {};
 	    for (var i = 0; i < source.length; ++i) {
 	        if (typeof source[i] !== 'undefined') {
 	            obj[i] = source[i];
@@ -52271,11 +52940,14 @@ function requireUtils () {
 	        return target;
 	    }
 
-	    if (typeof source !== 'object') {
+	    if (typeof source !== 'object' && typeof source !== 'function') {
 	        if (isArray(target)) {
 	            target.push(source);
 	        } else if (target && typeof target === 'object') {
-	            if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {
+	            if (
+	                (options && (options.plainObjects || options.allowPrototypes))
+	                || !has.call(Object.prototype, source)
+	            ) {
 	                target[source] = true;
 	            }
 	        } else {
@@ -52329,7 +53001,7 @@ function requireUtils () {
 	    }, target);
 	};
 
-	var decode = function (str, decoder, charset) {
+	var decode = function (str, defaultDecoder, charset) {
 	    var strWithoutPlus = str.replace(/\+/g, ' ');
 	    if (charset === 'iso-8859-1') {
 	        // unescape never throws, no try...catch needed:
@@ -52528,11 +53200,13 @@ function requireStringify () {
 	    arrayFormat: 'indices',
 	    charset: 'utf-8',
 	    charsetSentinel: false,
+	    commaRoundTrip: false,
 	    delimiter: '&',
 	    encode: true,
 	    encodeDotInKeys: false,
 	    encoder: utils.encode,
 	    encodeValuesOnly: false,
+	    filter: void 0,
 	    format: defaultFormat,
 	    formatter: formats.formatters[defaultFormat],
 	    // deprecated
@@ -52644,7 +53318,7 @@ function requireStringify () {
 	        objKeys = sort ? keys.sort(sort) : keys;
 	    }
 
-	    var encodedPrefix = encodeDotInKeys ? prefix.replace(/\./g, '%2E') : prefix;
+	    var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
 
 	    var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
 
@@ -52654,13 +53328,15 @@ function requireStringify () {
 
 	    for (var j = 0; j < objKeys.length; ++j) {
 	        var key = objKeys[j];
-	        var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];
+	        var value = typeof key === 'object' && key && typeof key.value !== 'undefined'
+	            ? key.value
+	            : obj[key];
 
 	        if (skipNulls && value === null) {
 	            continue;
 	        }
 
-	        var encodedKey = allowDots && encodeDotInKeys ? key.replace(/\./g, '%2E') : key;
+	        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, '%2E') : String(key);
 	        var keyPrefix = isArray(obj)
 	            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix
 	            : adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');
@@ -52751,7 +53427,7 @@ function requireStringify () {
 	        arrayFormat: arrayFormat,
 	        charset: charset,
 	        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
-	        commaRoundTrip: opts.commaRoundTrip,
+	        commaRoundTrip: !!opts.commaRoundTrip,
 	        delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
 	        encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
 	        encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
@@ -52802,12 +53478,13 @@ function requireStringify () {
 	    var sideChannel = getSideChannel();
 	    for (var i = 0; i < objKeys.length; ++i) {
 	        var key = objKeys[i];
+	        var value = obj[key];
 
-	        if (options.skipNulls && obj[key] === null) {
+	        if (options.skipNulls && value === null) {
 	            continue;
 	        }
 	        pushToArray(keys, stringify(
-	            obj[key],
+	            value,
 	            key,
 	            generateArrayPrefix,
 	            commaRoundTrip,
@@ -52878,7 +53555,8 @@ function requireParse () {
 	    parseArrays: true,
 	    plainObjects: false,
 	    strictDepth: false,
-	    strictNullHandling: false
+	    strictNullHandling: false,
+	    throwOnLimitExceeded: false
 	};
 
 	var interpretNumericEntities = function (str) {
@@ -52887,11 +53565,15 @@ function requireParse () {
 	    });
 	};
 
-	var parseArrayValue = function (val, options) {
+	var parseArrayValue = function (val, options, currentArrayLength) {
 	    if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
 	        return val.split(',');
 	    }
 
+	    if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
+	        throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	    }
+
 	    return val;
 	};
 
@@ -52910,8 +53592,17 @@ function requireParse () {
 
 	    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
 	    cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');
+
 	    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
-	    var parts = cleanStr.split(options.delimiter, limit);
+	    var parts = cleanStr.split(
+	        options.delimiter,
+	        options.throwOnLimitExceeded ? limit + 1 : limit
+	    );
+
+	    if (options.throwOnLimitExceeded && parts.length > limit) {
+	        throw new RangeError('Parameter limit exceeded. Only ' + limit + ' parameter' + (limit === 1 ? '' : 's') + ' allowed.');
+	    }
+
 	    var skipIndex = -1; // Keep track of where the utf8 sentinel was found
 	    var i;
 
@@ -52939,14 +53630,20 @@ function requireParse () {
 	        var bracketEqualsPos = part.indexOf(']=');
 	        var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
 
-	        var key, val;
+	        var key;
+	        var val;
 	        if (pos === -1) {
 	            key = options.decoder(part, defaults.decoder, charset, 'key');
 	            val = options.strictNullHandling ? null : '';
 	        } else {
 	            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
+
 	            val = utils.maybeMap(
-	                parseArrayValue(part.slice(pos + 1), options),
+	                parseArrayValue(
+	                    part.slice(pos + 1),
+	                    options,
+	                    isArray(obj[key]) ? obj[key].length : 0
+	                ),
 	                function (encodedVal) {
 	                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');
 	                }
@@ -52954,7 +53651,7 @@ function requireParse () {
 	        }
 
 	        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
-	            val = interpretNumericEntities(val);
+	            val = interpretNumericEntities(String(val));
 	        }
 
 	        if (part.indexOf('[]=') > -1) {
@@ -52973,7 +53670,13 @@ function requireParse () {
 	};
 
 	var parseObject = function (chain, val, options, valuesParsed) {
-	    var leaf = valuesParsed ? val : parseArrayValue(val, options);
+	    var currentArrayLength = 0;
+	    if (chain.length > 0 && chain[chain.length - 1] === '[]') {
+	        var parentKey = chain.slice(0, -1).join('');
+	        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
+	    }
+
+	    var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
 
 	    for (var i = chain.length - 1; i >= 0; --i) {
 	        var obj;
@@ -52982,9 +53685,9 @@ function requireParse () {
 	        if (root === '[]' && options.parseArrays) {
 	            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
 	                ? []
-	                : [].concat(leaf);
+	                : utils.combine([], leaf);
 	        } else {
-	            obj = options.plainObjects ? Object.create(null) : {};
+	            obj = options.plainObjects ? { __proto__: null } : {};
 	            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
 	            var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;
 	            var index = parseInt(decodedRoot, 10);
@@ -53087,6 +53790,11 @@ function requireParse () {
 	    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
 	        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
 	    }
+
+	    if (typeof opts.throwOnLimitExceeded !== 'undefined' && typeof opts.throwOnLimitExceeded !== 'boolean') {
+	        throw new TypeError('`throwOnLimitExceeded` option must be a boolean');
+	    }
+
 	    var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
 
 	    var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;
@@ -53118,7 +53826,8 @@ function requireParse () {
 	        parseArrays: opts.parseArrays !== false,
 	        plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
 	        strictDepth: typeof opts.strictDepth === 'boolean' ? !!opts.strictDepth : defaults.strictDepth,
-	        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
+	        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
+	        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === 'boolean' ? opts.throwOnLimitExceeded : false
 	    };
 	};
 
@@ -53126,11 +53835,11 @@ function requireParse () {
 	    var options = normalizeParseOptions(opts);
 
 	    if (str === '' || str === null || typeof str === 'undefined') {
-	        return options.plainObjects ? Object.create(null) : {};
+	        return options.plainObjects ? { __proto__: null } : {};
 	    }
 
 	    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
-	    var obj = options.plainObjects ? Object.create(null) : {};
+	    var obj = options.plainObjects ? { __proto__: null } : {};
 
 	    // Iterate over the keys and setup the new object
 
@@ -53660,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-CLvDQIrx.js.map
+//# sourceMappingURL=vendor-BxO3IPg6.js.map