@next-font/plugin-vite 1.2.2-canary.0 → 1.3.0

package/dist/index-y2m5QvKY.js

@@ -0,0 +1,3851 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import require$$0, { win32, posix } from 'path';
+import require$$3 from 'crypto';
+import { isCSSRequest } from 'vite';
+import require$$0$1 from 'postcss';
+
+// From https://github.com/vercel/next.js/blob/a90f0c91d6063d25be513779cb21fb8892ba4201/packages/next/src/build/webpack/plugins/next-font-manifest-plugin.ts
+/**
+ * When calling font functions with next/font, you can specify if you'd like the font to be preloaded (true by default).
+ * e.g.: const inter = Inter({ subsets: ['latin'], preload: true })
+ *
+ * In that case, next-font-loader will emit the font file as [name].p.[ext] instead of [name].[ext]
+ * This function returns those files from an array that can include both preloaded and non-preloaded files.
+ */ function getPreloadedFontFiles(fontFiles) {
+    return fontFiles.filter((file)=>/\.p\.(woff|woff2|eot|ttf|otf)$/.test(file));
+}
+/**
+ * Similarly to getPreloadedFontFiles, but returns true if some of the files includes -s in the name.
+ * This means that a font is using size adjust in its fallback font.
+ * This was added to enable adding data-size-adjust="true" to the dom, used by the Google Aurora team to collect statistics.
+ */ function getPageIsUsingSizeAdjust(fontFiles) {
+    return fontFiles.some((file)=>file.includes('-s'));
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, posix.sep);
+};
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+function stringify$1(obj) {
+    return (JSON.stringify(obj) || 'undefined').replace(/[\u2028\u2029]/g, (char)=>`\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+}
+function serializeArray(arr, indent, baseIndent) {
+    let output = '[';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    for(let i = 0; i < arr.length; i++){
+        const key = arr[i];
+        output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}]`;
+}
+function serializeObject(obj, indent, baseIndent) {
+    let output = '{';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    const entries = Object.entries(obj);
+    for(let i = 0; i < entries.length; i++){
+        const [key, value] = entries[i];
+        const stringKey = makeLegalIdentifier(key) === key ? key : stringify$1(key);
+        output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(value, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}}`;
+}
+function serialize(obj, indent, baseIndent) {
+    if (typeof obj === 'object' && obj !== null) {
+        if (Array.isArray(obj)) return serializeArray(obj, indent, baseIndent);
+        if (obj instanceof Date) return `new Date(${obj.getTime()})`;
+        if (obj instanceof RegExp) return obj.toString();
+        return serializeObject(obj, indent, baseIndent);
+    }
+    if (typeof obj === 'number') {
+        if (obj === Infinity) return 'Infinity';
+        if (obj === -Infinity) return '-Infinity';
+        if (obj === 0) return 1 / obj === Infinity ? '0' : '-0';
+        if (obj !== obj) return 'NaN'; // eslint-disable-line no-self-compare
+    }
+    if (typeof obj === 'symbol') {
+        const key = Symbol.keyFor(obj);
+        // eslint-disable-next-line no-undefined
+        if (key !== undefined) return `Symbol.for(${stringify$1(key)})`;
+    }
+    if (typeof obj === 'bigint') return `${obj}n`;
+    return stringify$1(obj);
+}
+// isWellFormed exists from Node.js 20
+const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
+function isWellFormedString(input) {
+    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
+    if (hasStringIsWellFormed) return input.isWellFormed();
+    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
+    return !/\p{Surrogate}/u.test(input);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    var _a, _b;
+    const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
+    const _ = options.compact ? '' : ' ';
+    const n = options.compact ? '' : '\n';
+    const declarationType = options.preferConst ? 'const' : 'var';
+    if (options.namedExports === false || typeof data !== 'object' || Array.isArray(data) || data instanceof Date || data instanceof RegExp || data === null) {
+        const code = serialize(data, options.compact ? null : t, '');
+        const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
+        return `export default${magic}${code};`;
+    }
+    let maxUnderbarPrefixLength = 0;
+    for (const key of Object.keys(data)){
+        const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        if (underbarPrefixLength > maxUnderbarPrefixLength) {
+            maxUnderbarPrefixLength = underbarPrefixLength;
+        }
+    }
+    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    const arbitraryNameExportRows = [];
+    for (const [key, value] of Object.entries(data)){
+        if (key === makeLegalIdentifier(key)) {
+            if (options.objectShorthand) defaultExportRows.push(key);
+            else defaultExportRows.push(`${key}:${_}${key}`);
+            namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+        } else {
+            defaultExportRows.push(`${stringify$1(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
+            if (options.includeArbitraryNames && isWellFormedString(key)) {
+                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+            }
+        }
+    }
+    const arbitraryExportCode = arbitraryNameExportRows.length > 0 ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}` : '';
+    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
+};
+
+var lib = {};
+
+var isUrlRequest_1;
+var hasRequiredIsUrlRequest;
+
+function requireIsUrlRequest () {
+	if (hasRequiredIsUrlRequest) return isUrlRequest_1;
+	hasRequiredIsUrlRequest = 1;
+	const path = require$$0;
+	function isUrlRequest(url) {
+	    // An URL is not an request if
+	    // 1. Allow `data URI`
+	    if (/^data:/i.test(url)) {
+	        return true;
+	    }
+	    // 2. It's an absolute url and it is not `windows` path like `C:\dir\file`
+	    if (/^[a-z][a-z0-9+.-]*:/i.test(url) && !path.win32.isAbsolute(url)) {
+	        return false;
+	    }
+	    // 3. It's a protocol-relative
+	    if (/^\/\//.test(url)) {
+	        return false;
+	    }
+	    // 4. It's some kind of url for a template
+	    if (/^#/.test(url)) {
+	        return false;
+	    }
+	    return true;
+	}
+	isUrlRequest_1 = isUrlRequest;
+	return isUrlRequest_1;
+}
+
+var urlToRequest_1;
+var hasRequiredUrlToRequest;
+
+function requireUrlToRequest () {
+	if (hasRequiredUrlToRequest) return urlToRequest_1;
+	hasRequiredUrlToRequest = 1;
+	// we can't use path.win32.isAbsolute because it also matches paths starting with a forward slash
+	const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
+	function urlToRequest(url, root) {
+	    // Do not rewrite an empty url
+	    if (url === "") {
+	        return "";
+	    }
+	    const moduleRequestRegex = /^[^?]*~/;
+	    let request;
+	    if (matchNativeWin32Path.test(url)) {
+	        // absolute windows path, keep it
+	        request = url;
+	    } else if (root !== undefined && root !== false && /^\//.test(url)) {
+	        // if root is set and the url is root-relative
+	        switch(typeof root){
+	            // 1. root is a string: root is prefixed to the url
+	            case "string":
+	                // special case: `~` roots convert to module request
+	                if (moduleRequestRegex.test(root)) {
+	                    request = root.replace(/([^~/])$/, "$1/") + url.slice(1);
+	                } else {
+	                    request = root + url;
+	                }
+	                break;
+	            // 2. root is `true`: absolute paths are allowed
+	            //    *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/`
+	            case "boolean":
+	                request = url;
+	                break;
+	            default:
+	                throw new Error("Unexpected parameters to loader-utils 'urlToRequest': url = " + url + ", root = " + root + ".");
+	        }
+	    } else if (/^\.\.?\//.test(url)) {
+	        // A relative url stays
+	        request = url;
+	    } else {
+	        // every other url is threaded like a relative url
+	        request = "./" + url;
+	    }
+	    // A `~` makes the url an module
+	    if (moduleRequestRegex.test(request)) {
+	        request = request.replace(moduleRequestRegex, "");
+	    }
+	    return request;
+	}
+	urlToRequest_1 = urlToRequest;
+	return urlToRequest_1;
+}
+
+var wasmHash = {exports: {}};
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var hasRequiredWasmHash;
+
+function requireWasmHash () {
+	if (hasRequiredWasmHash) return wasmHash.exports;
+	hasRequiredWasmHash = 1;
+	// 65536 is the size of a wasm memory page
+	// 64 is the maximum chunk size for every possible wasm hash implementation
+	// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+	// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+	const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & -4;
+	class WasmHash {
+	    /**
+	   * @param {WebAssembly.Instance} instance wasm instance
+	   * @param {WebAssembly.Instance[]} instancesPool pool of instances
+	   * @param {number} chunkSize size of data chunks passed to wasm
+	   * @param {number} digestSize size of digest returned by wasm
+	   */ constructor(instance, instancesPool, chunkSize, digestSize){
+	        const exports = /** @type {any} */ instance.exports;
+	        exports.init();
+	        this.exports = exports;
+	        this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+	        this.buffered = 0;
+	        this.instancesPool = instancesPool;
+	        this.chunkSize = chunkSize;
+	        this.digestSize = digestSize;
+	    }
+	    reset() {
+	        this.buffered = 0;
+	        this.exports.init();
+	    }
+	    /**
+	   * @param {Buffer | string} data data
+	   * @param {BufferEncoding=} encoding encoding
+	   * @returns {this} itself
+	   */ update(data, encoding) {
+	        if (typeof data === "string") {
+	            while(data.length > MAX_SHORT_STRING){
+	                this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+	                data = data.slice(MAX_SHORT_STRING);
+	            }
+	            this._updateWithShortString(data, encoding);
+	            return this;
+	        }
+	        this._updateWithBuffer(data);
+	        return this;
+	    }
+	    /**
+	   * @param {string} data data
+	   * @param {BufferEncoding=} encoding encoding
+	   * @returns {void}
+	   */ _updateWithShortString(data, encoding) {
+	        const { exports, buffered, mem, chunkSize } = this;
+	        let endPos;
+	        if (data.length < 70) {
+	            if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+	                endPos = buffered;
+	                for(let i = 0; i < data.length; i++){
+	                    const cc = data.charCodeAt(i);
+	                    if (cc < 0x80) {
+	                        mem[endPos++] = cc;
+	                    } else if (cc < 0x800) {
+	                        mem[endPos] = cc >> 6 | 0xc0;
+	                        mem[endPos + 1] = cc & 0x3f | 0x80;
+	                        endPos += 2;
+	                    } else {
+	                        // bail-out for weird chars
+	                        endPos += mem.write(data.slice(i), endPos, encoding);
+	                        break;
+	                    }
+	                }
+	            } else if (encoding === "latin1") {
+	                endPos = buffered;
+	                for(let i = 0; i < data.length; i++){
+	                    const cc = data.charCodeAt(i);
+	                    mem[endPos++] = cc;
+	                }
+	            } else {
+	                endPos = buffered + mem.write(data, buffered, encoding);
+	            }
+	        } else {
+	            endPos = buffered + mem.write(data, buffered, encoding);
+	        }
+	        if (endPos < chunkSize) {
+	            this.buffered = endPos;
+	        } else {
+	            const l = endPos & ~(this.chunkSize - 1);
+	            exports.update(l);
+	            const newBuffered = endPos - l;
+	            this.buffered = newBuffered;
+	            if (newBuffered > 0) {
+	                mem.copyWithin(0, l, endPos);
+	            }
+	        }
+	    }
+	    /**
+	   * @param {Buffer} data data
+	   * @returns {void}
+	   */ _updateWithBuffer(data) {
+	        const { exports, buffered, mem } = this;
+	        const length = data.length;
+	        if (buffered + length < this.chunkSize) {
+	            data.copy(mem, buffered, 0, length);
+	            this.buffered += length;
+	        } else {
+	            const l = buffered + length & ~(this.chunkSize - 1);
+	            if (l > 65536) {
+	                let i = 65536 - buffered;
+	                data.copy(mem, buffered, 0, i);
+	                exports.update(65536);
+	                const stop = l - buffered - 65536;
+	                while(i < stop){
+	                    data.copy(mem, 0, i, i + 65536);
+	                    exports.update(65536);
+	                    i += 65536;
+	                }
+	                data.copy(mem, 0, i, l - buffered);
+	                exports.update(l - buffered - i);
+	            } else {
+	                data.copy(mem, buffered, 0, l - buffered);
+	                exports.update(l);
+	            }
+	            const newBuffered = length + buffered - l;
+	            this.buffered = newBuffered;
+	            if (newBuffered > 0) {
+	                data.copy(mem, 0, length - newBuffered, length);
+	            }
+	        }
+	    }
+	    digest(type) {
+	        const { exports, buffered, mem, digestSize } = this;
+	        exports.final(buffered);
+	        this.instancesPool.push(this);
+	        const hex = mem.toString("latin1", 0, digestSize);
+	        if (type === "hex") {
+	            return hex;
+	        }
+	        if (type === "binary" || !type) {
+	            return Buffer.from(hex, "hex");
+	        }
+	        return Buffer.from(hex, "hex").toString(type);
+	    }
+	}
+	const create = (wasmModule, instancesPool, chunkSize, digestSize)=>{
+	    if (instancesPool.length > 0) {
+	        const old = instancesPool.pop();
+	        old.reset();
+	        return old;
+	    } else {
+	        return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
+	    }
+	};
+	wasmHash.exports = create;
+	wasmHash.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+	return wasmHash.exports;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var xxhash64_1;
+var hasRequiredXxhash64;
+
+function requireXxhash64 () {
+	if (hasRequiredXxhash64) return xxhash64_1;
+	hasRequiredXxhash64 = 1;
+	const create = requireWasmHash();
+	//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+	const xxhash64 = new WebAssembly.Module(Buffer.from(// 1173 bytes
+	"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL", "base64"));
+	//#endregion
+	xxhash64_1 = create.bind(null, xxhash64, [], 32, 16);
+	return xxhash64_1;
+}
+
+var BatchedHash_1;
+var hasRequiredBatchedHash;
+
+function requireBatchedHash () {
+	if (hasRequiredBatchedHash) return BatchedHash_1;
+	hasRequiredBatchedHash = 1;
+	const MAX_SHORT_STRING = requireWasmHash().MAX_SHORT_STRING;
+	class BatchedHash {
+	    constructor(hash){
+	        this.string = undefined;
+	        this.encoding = undefined;
+	        this.hash = hash;
+	    }
+	    /**
+	   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	   * @param {string|Buffer} data data
+	   * @param {string=} inputEncoding data encoding
+	   * @returns {this} updated hash
+	   */ update(data, inputEncoding) {
+	        if (this.string !== undefined) {
+	            if (typeof data === "string" && inputEncoding === this.encoding && this.string.length + data.length < MAX_SHORT_STRING) {
+	                this.string += data;
+	                return this;
+	            }
+	            this.hash.update(this.string, this.encoding);
+	            this.string = undefined;
+	        }
+	        if (typeof data === "string") {
+	            if (data.length < MAX_SHORT_STRING && // base64 encoding is not valid since it may contain padding chars
+	            (!inputEncoding || !inputEncoding.startsWith("ba"))) {
+	                this.string = data;
+	                this.encoding = inputEncoding;
+	            } else {
+	                this.hash.update(data, inputEncoding);
+	            }
+	        } else {
+	            this.hash.update(data);
+	        }
+	        return this;
+	    }
+	    /**
+	   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	   * @param {string=} encoding encoding of the return value
+	   * @returns {string|Buffer} digest
+	   */ digest(encoding) {
+	        if (this.string !== undefined) {
+	            this.hash.update(this.string, this.encoding);
+	        }
+	        return this.hash.digest(encoding);
+	    }
+	}
+	BatchedHash_1 = BatchedHash;
+	return BatchedHash_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var md4_1;
+var hasRequiredMd4;
+
+function requireMd4 () {
+	if (hasRequiredMd4) return md4_1;
+	hasRequiredMd4 = 1;
+	const create = requireWasmHash();
+	//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+	const md4 = new WebAssembly.Module(Buffer.from(// 2150 bytes
+	"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", "base64"));
+	//#endregion
+	md4_1 = create.bind(null, md4, [], 64, 32);
+	return md4_1;
+}
+
+var BulkUpdateDecorator_1;
+var hasRequiredBulkUpdateDecorator;
+
+function requireBulkUpdateDecorator () {
+	if (hasRequiredBulkUpdateDecorator) return BulkUpdateDecorator_1;
+	hasRequiredBulkUpdateDecorator = 1;
+	const BULK_SIZE = 2000;
+	// We are using an object instead of a Map as this will stay static during the runtime
+	// so access to it can be optimized by v8
+	const digestCaches = {};
+	class BulkUpdateDecorator {
+	    /**
+	   * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	   * @param {string=} hashKey key for caching
+	   */ constructor(hashOrFactory, hashKey){
+	        this.hashKey = hashKey;
+	        if (typeof hashOrFactory === "function") {
+	            this.hashFactory = hashOrFactory;
+	            this.hash = undefined;
+	        } else {
+	            this.hashFactory = undefined;
+	            this.hash = hashOrFactory;
+	        }
+	        this.buffer = "";
+	    }
+	    /**
+	   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	   * @param {string|Buffer} data data
+	   * @param {string=} inputEncoding data encoding
+	   * @returns {this} updated hash
+	   */ update(data, inputEncoding) {
+	        if (inputEncoding !== undefined || typeof data !== "string" || data.length > BULK_SIZE) {
+	            if (this.hash === undefined) {
+	                this.hash = this.hashFactory();
+	            }
+	            if (this.buffer.length > 0) {
+	                this.hash.update(this.buffer);
+	                this.buffer = "";
+	            }
+	            this.hash.update(data, inputEncoding);
+	        } else {
+	            this.buffer += data;
+	            if (this.buffer.length > BULK_SIZE) {
+	                if (this.hash === undefined) {
+	                    this.hash = this.hashFactory();
+	                }
+	                this.hash.update(this.buffer);
+	                this.buffer = "";
+	            }
+	        }
+	        return this;
+	    }
+	    /**
+	   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	   * @param {string=} encoding encoding of the return value
+	   * @returns {string|Buffer} digest
+	   */ digest(encoding) {
+	        let digestCache;
+	        const buffer = this.buffer;
+	        if (this.hash === undefined) {
+	            // short data for hash, we can use caching
+	            const cacheKey = `${this.hashKey}-${encoding}`;
+	            digestCache = digestCaches[cacheKey];
+	            if (digestCache === undefined) {
+	                digestCache = digestCaches[cacheKey] = new Map();
+	            }
+	            const cacheEntry = digestCache.get(buffer);
+	            if (cacheEntry !== undefined) {
+	                return cacheEntry;
+	            }
+	            this.hash = this.hashFactory();
+	        }
+	        if (buffer.length > 0) {
+	            this.hash.update(buffer);
+	        }
+	        const digestResult = this.hash.digest(encoding);
+	        if (digestCache !== undefined) {
+	            digestCache.set(buffer, digestResult);
+	        }
+	        return digestResult;
+	    }
+	}
+	BulkUpdateDecorator_1 = BulkUpdateDecorator;
+	return BulkUpdateDecorator_1;
+}
+
+var getHashDigest_1;
+var hasRequiredGetHashDigest;
+
+function requireGetHashDigest () {
+	if (hasRequiredGetHashDigest) return getHashDigest_1;
+	hasRequiredGetHashDigest = 1;
+	const baseEncodeTables = {
+	    26: "abcdefghijklmnopqrstuvwxyz",
+	    32: "123456789abcdefghjkmnpqrstuvwxyz",
+	    36: "0123456789abcdefghijklmnopqrstuvwxyz",
+	    49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+	    52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+	    58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+	    62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+	    64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+	};
+	/**
+	 * @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
+	 * @param {number} divisor The divisor
+	 * @return {number} Modulo (remainder) of the division
+	 */ function divmod32(uint32Array, divisor) {
+	    let carry = 0;
+	    for(let i = uint32Array.length - 1; i >= 0; i--){
+	        const value = carry * 0x100000000 + uint32Array[i];
+	        carry = value % divisor;
+	        uint32Array[i] = Math.floor(value / divisor);
+	    }
+	    return carry;
+	}
+	function encodeBufferToBase(buffer, base, length) {
+	    const encodeTable = baseEncodeTables[base];
+	    if (!encodeTable) {
+	        throw new Error("Unknown encoding base" + base);
+	    }
+	    // Input bits are only enough to generate this many characters
+	    const limit = Math.ceil(buffer.length * 8 / Math.log2(base));
+	    length = Math.min(length, limit);
+	    // Most of the crypto digests (if not all) has length a multiple of 4 bytes.
+	    // Fewer numbers in the array means faster math.
+	    const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4));
+	    // Make sure the input buffer data is copied and is not mutated by reference.
+	    // divmod32() would corrupt the BulkUpdateDecorator cache otherwise.
+	    buffer.copy(Buffer.from(uint32Array.buffer));
+	    let output = "";
+	    for(let i = 0; i < length; i++){
+	        output = encodeTable[divmod32(uint32Array, base)] + output;
+	    }
+	    return output;
+	}
+	let crypto = undefined;
+	let createXXHash64 = undefined;
+	let createMd4 = undefined;
+	let BatchedHash = undefined;
+	let BulkUpdateDecorator = undefined;
+	function getHashDigest(buffer, algorithm, digestType, maxLength) {
+	    algorithm = algorithm || "xxhash64";
+	    maxLength = maxLength || 9999;
+	    let hash;
+	    if (algorithm === "xxhash64") {
+	        if (createXXHash64 === undefined) {
+	            createXXHash64 = requireXxhash64();
+	            if (BatchedHash === undefined) {
+	                BatchedHash = requireBatchedHash();
+	            }
+	        }
+	        hash = new BatchedHash(createXXHash64());
+	    } else if (algorithm === "md4") {
+	        if (createMd4 === undefined) {
+	            createMd4 = requireMd4();
+	            if (BatchedHash === undefined) {
+	                BatchedHash = requireBatchedHash();
+	            }
+	        }
+	        hash = new BatchedHash(createMd4());
+	    } else if (algorithm === "native-md4") {
+	        if (typeof crypto === "undefined") {
+	            crypto = require$$3;
+	            if (BulkUpdateDecorator === undefined) {
+	                BulkUpdateDecorator = requireBulkUpdateDecorator();
+	            }
+	        }
+	        hash = new BulkUpdateDecorator(()=>crypto.createHash("md4"), "md4");
+	    } else {
+	        if (typeof crypto === "undefined") {
+	            crypto = require$$3;
+	            if (BulkUpdateDecorator === undefined) {
+	                BulkUpdateDecorator = requireBulkUpdateDecorator();
+	            }
+	        }
+	        hash = new BulkUpdateDecorator(()=>crypto.createHash(algorithm), algorithm);
+	    }
+	    hash.update(buffer);
+	    if (digestType === "base26" || digestType === "base32" || digestType === "base36" || digestType === "base49" || digestType === "base52" || digestType === "base58" || digestType === "base62" || digestType === "base64safe") {
+	        return encodeBufferToBase(hash.digest(), digestType === "base64safe" ? 64 : digestType.substr(4), maxLength);
+	    }
+	    return hash.digest(digestType || "hex").substr(0, maxLength);
+	}
+	getHashDigest_1 = getHashDigest;
+	return getHashDigest_1;
+}
+
+var interpolateName_1;
+var hasRequiredInterpolateName;
+
+function requireInterpolateName () {
+	if (hasRequiredInterpolateName) return interpolateName_1;
+	hasRequiredInterpolateName = 1;
+	const path = require$$0;
+	const getHashDigest = requireGetHashDigest();
+	function interpolateName(loaderContext, name, options = {}) {
+	    let filename;
+	    const hasQuery = loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+	    if (typeof name === "function") {
+	        filename = name(loaderContext.resourcePath, hasQuery ? loaderContext.resourceQuery : undefined);
+	    } else {
+	        filename = name || "[hash].[ext]";
+	    }
+	    const context = options.context;
+	    const content = options.content;
+	    const regExp = options.regExp;
+	    let ext = "bin";
+	    let basename = "file";
+	    let directory = "";
+	    let folder = "";
+	    let query = "";
+	    if (loaderContext.resourcePath) {
+	        const parsed = path.parse(loaderContext.resourcePath);
+	        let resourcePath = loaderContext.resourcePath;
+	        if (parsed.ext) {
+	            ext = parsed.ext.substr(1);
+	        }
+	        if (parsed.dir) {
+	            basename = parsed.name;
+	            resourcePath = parsed.dir + path.sep;
+	        }
+	        if (typeof context !== "undefined") {
+	            directory = path.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+	            directory = directory.substr(0, directory.length - 1);
+	        } else {
+	            directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+	        }
+	        if (directory.length <= 1) {
+	            directory = "";
+	        } else {
+	            // directory.length > 1
+	            folder = path.basename(directory);
+	        }
+	    }
+	    if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+	        query = loaderContext.resourceQuery;
+	        const hashIdx = query.indexOf("#");
+	        if (hashIdx >= 0) {
+	            query = query.substr(0, hashIdx);
+	        }
+	    }
+	    let url = filename;
+	    if (content) {
+	        // Match hash template
+	        url = url// `hash` and `contenthash` are same in `loader-utils` context
+	        // let's keep `hash` for backward compatibility
+	        .replace(/\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi, (all, hashType, digestType, maxLength)=>getHashDigest(content, hashType, digestType, parseInt(maxLength, 10)));
+	    }
+	    url = url.replace(/\[ext\]/gi, ()=>ext).replace(/\[name\]/gi, ()=>basename).replace(/\[path\]/gi, ()=>directory).replace(/\[folder\]/gi, ()=>folder).replace(/\[query\]/gi, ()=>query);
+	    if (regExp && loaderContext.resourcePath) {
+	        const match = loaderContext.resourcePath.match(new RegExp(regExp));
+	        match && match.forEach((matched, i)=>{
+	            url = url.replace(new RegExp("\\[" + i + "\\]", "ig"), matched);
+	        });
+	    }
+	    if (typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") {
+	        url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options);
+	    }
+	    return url;
+	}
+	interpolateName_1 = interpolateName;
+	return interpolateName_1;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	const isUrlRequest = requireIsUrlRequest();
+	const urlToRequest = requireUrlToRequest();
+	const getHashDigest = requireGetHashDigest();
+	const interpolateName = requireInterpolateName();
+	lib.urlToRequest = urlToRequest;
+	lib.getHashDigest = getHashDigest;
+	lib.interpolateName = interpolateName;
+	lib.isUrlRequest = isUrlRequest;
+	return lib;
+}
+
+var libExports = requireLib();
+var loaderUtils = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for(let i = 0; i < chars.length; i++){
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+    do {
+        let clamped = delta & 31;
+        delta >>>= 5;
+        if (delta > 0) clamped |= 32;
+        builder.write(intToChar[clamped]);
+    }while (delta > 0)
+    return num;
+}
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+    decode (buf) {
+        const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+        return out.toString();
+    }
+} : {
+    decode (buf) {
+        let out = "";
+        for(let i = 0; i < buf.length; i++){
+            out += String.fromCharCode(buf[i]);
+        }
+        return out;
+    }
+};
+var StringWriter = class {
+    constructor(){
+        this.pos = 0;
+        this.out = "";
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+};
+function encode$1(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for(let i = 0; i < decoded.length; i++){
+        const line = decoded[i];
+        if (i > 0) writer.write(semicolon);
+        if (line.length === 0) continue;
+        let genColumn = 0;
+        for(let j = 0; j < line.length; j++){
+            const segment = line[j];
+            if (j > 0) writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1) continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4) continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+class BitSet {
+    constructor(arg){
+        this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+    }
+    add(n) {
+        this.bits[n >> 5] |= 1 << (n & 31);
+    }
+    has(n) {
+        return !!(this.bits[n >> 5] & 1 << (n & 31));
+    }
+}
+class Chunk {
+    constructor(start, end, content){
+        this.start = start;
+        this.end = end;
+        this.original = content;
+        this.intro = '';
+        this.outro = '';
+        this.content = content;
+        this.storeName = false;
+        this.edited = false;
+        {
+            this.previous = null;
+            this.next = null;
+        }
+    }
+    appendLeft(content) {
+        this.outro += content;
+    }
+    appendRight(content) {
+        this.intro = this.intro + content;
+    }
+    clone() {
+        const chunk = new Chunk(this.start, this.end, this.original);
+        chunk.intro = this.intro;
+        chunk.outro = this.outro;
+        chunk.content = this.content;
+        chunk.storeName = this.storeName;
+        chunk.edited = this.edited;
+        return chunk;
+    }
+    contains(index) {
+        return this.start < index && index < this.end;
+    }
+    eachNext(fn) {
+        let chunk = this;
+        while(chunk){
+            fn(chunk);
+            chunk = chunk.next;
+        }
+    }
+    eachPrevious(fn) {
+        let chunk = this;
+        while(chunk){
+            fn(chunk);
+            chunk = chunk.previous;
+        }
+    }
+    edit(content, storeName, contentOnly) {
+        this.content = content;
+        if (!contentOnly) {
+            this.intro = '';
+            this.outro = '';
+        }
+        this.storeName = storeName;
+        this.edited = true;
+        return this;
+    }
+    prependLeft(content) {
+        this.outro = content + this.outro;
+    }
+    prependRight(content) {
+        this.intro = content + this.intro;
+    }
+    reset() {
+        this.intro = '';
+        this.outro = '';
+        if (this.edited) {
+            this.content = this.original;
+            this.storeName = false;
+            this.edited = false;
+        }
+    }
+    split(index) {
+        const sliceIndex = index - this.start;
+        const originalBefore = this.original.slice(0, sliceIndex);
+        const originalAfter = this.original.slice(sliceIndex);
+        this.original = originalBefore;
+        const newChunk = new Chunk(index, this.end, originalAfter);
+        newChunk.outro = this.outro;
+        this.outro = '';
+        this.end = index;
+        if (this.edited) {
+            // after split we should save the edit content record into the correct chunk
+            // to make sure sourcemap correct
+            // For example:
+            // '  test'.trim()
+            //     split   -> '  ' + 'test'
+            //   ✔️ edit    -> '' + 'test'
+            //   ✖️ edit    -> 'test' + ''
+            // TODO is this block necessary?...
+            newChunk.edit('', false);
+            this.content = '';
+        } else {
+            this.content = originalBefore;
+        }
+        newChunk.next = this.next;
+        if (newChunk.next) newChunk.next.previous = newChunk;
+        newChunk.previous = this;
+        this.next = newChunk;
+        return newChunk;
+    }
+    toString() {
+        return this.intro + this.content + this.outro;
+    }
+    trimEnd(rx) {
+        this.outro = this.outro.replace(rx, '');
+        if (this.outro.length) return true;
+        const trimmed = this.content.replace(rx, '');
+        if (trimmed.length) {
+            if (trimmed !== this.content) {
+                this.split(this.start + trimmed.length).edit('', undefined, true);
+                if (this.edited) {
+                    // save the change, if it has been edited
+                    this.edit(trimmed, this.storeName, true);
+                }
+            }
+            return true;
+        } else {
+            this.edit('', undefined, true);
+            this.intro = this.intro.replace(rx, '');
+            if (this.intro.length) return true;
+        }
+    }
+    trimStart(rx) {
+        this.intro = this.intro.replace(rx, '');
+        if (this.intro.length) return true;
+        const trimmed = this.content.replace(rx, '');
+        if (trimmed.length) {
+            if (trimmed !== this.content) {
+                const newChunk = this.split(this.end - trimmed.length);
+                if (this.edited) {
+                    // save the change, if it has been edited
+                    newChunk.edit(trimmed, this.storeName, true);
+                }
+                this.edit('', undefined, true);
+            }
+            return true;
+        } else {
+            this.edit('', undefined, true);
+            this.outro = this.outro.replace(rx, '');
+            if (this.outro.length) return true;
+        }
+    }
+}
+function getBtoa() {
+    if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+        return (str)=>globalThis.btoa(unescape(encodeURIComponent(str)));
+    } else if (typeof Buffer === 'function') {
+        return (str)=>Buffer.from(str, 'utf-8').toString('base64');
+    } else {
+        return ()=>{
+            throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+        };
+    }
+}
+const btoa = /*#__PURE__*/ getBtoa();
+class SourceMap {
+    constructor(properties){
+        this.version = 3;
+        this.file = properties.file;
+        this.sources = properties.sources;
+        this.sourcesContent = properties.sourcesContent;
+        this.names = properties.names;
+        this.mappings = encode$1(properties.mappings);
+        if (typeof properties.x_google_ignoreList !== 'undefined') {
+            this.x_google_ignoreList = properties.x_google_ignoreList;
+        }
+        if (typeof properties.debugId !== 'undefined') {
+            this.debugId = properties.debugId;
+        }
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    toUrl() {
+        return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+    }
+}
+function guessIndent(code) {
+    const lines = code.split('\n');
+    const tabbed = lines.filter((line)=>/^\t+/.test(line));
+    const spaced = lines.filter((line)=>/^ {2,}/.test(line));
+    if (tabbed.length === 0 && spaced.length === 0) {
+        return null;
+    }
+    // More lines tabbed than spaced? Assume tabs, and
+    // default to tabs in the case of a tie (or nothing
+    // to go on)
+    if (tabbed.length >= spaced.length) {
+        return '\t';
+    }
+    // Otherwise, we need to guess the multiple
+    const min = spaced.reduce((previous, current)=>{
+        const numSpaces = /^ +/.exec(current)[0].length;
+        return Math.min(numSpaces, previous);
+    }, Infinity);
+    return new Array(min + 1).join(' ');
+}
+function getRelativePath(from, to) {
+    const fromParts = from.split(/[/\\]/);
+    const toParts = to.split(/[/\\]/);
+    fromParts.pop(); // get dirname
+    while(fromParts[0] === toParts[0]){
+        fromParts.shift();
+        toParts.shift();
+    }
+    if (fromParts.length) {
+        let i = fromParts.length;
+        while(i--)fromParts[i] = '..';
+    }
+    return fromParts.concat(toParts).join('/');
+}
+const toString = Object.prototype.toString;
+function isObject(thing) {
+    return toString.call(thing) === '[object Object]';
+}
+function getLocator(source) {
+    const originalLines = source.split('\n');
+    const lineOffsets = [];
+    for(let i = 0, pos = 0; i < originalLines.length; i++){
+        lineOffsets.push(pos);
+        pos += originalLines[i].length + 1;
+    }
+    return function locate(index) {
+        let i = 0;
+        let j = lineOffsets.length;
+        while(i < j){
+            const m = i + j >> 1;
+            if (index < lineOffsets[m]) {
+                j = m;
+            } else {
+                i = m + 1;
+            }
+        }
+        const line = i - 1;
+        const column = index - lineOffsets[line];
+        return {
+            line,
+            column
+        };
+    };
+}
+const wordRegex = /\w/;
+class Mappings {
+    constructor(hires){
+        this.hires = hires;
+        this.generatedCodeLine = 0;
+        this.generatedCodeColumn = 0;
+        this.raw = [];
+        this.rawSegments = this.raw[this.generatedCodeLine] = [];
+        this.pending = null;
+    }
+    addEdit(sourceIndex, content, loc, nameIndex) {
+        if (content.length) {
+            const contentLengthMinusOne = content.length - 1;
+            let contentLineEnd = content.indexOf('\n', 0);
+            let previousContentLineEnd = -1;
+            // Loop through each line in the content and add a segment, but stop if the last line is empty,
+            // else code afterwards would fill one line too many
+            while(contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd){
+                const segment = [
+                    this.generatedCodeColumn,
+                    sourceIndex,
+                    loc.line,
+                    loc.column
+                ];
+                if (nameIndex >= 0) {
+                    segment.push(nameIndex);
+                }
+                this.rawSegments.push(segment);
+                this.generatedCodeLine += 1;
+                this.raw[this.generatedCodeLine] = this.rawSegments = [];
+                this.generatedCodeColumn = 0;
+                previousContentLineEnd = contentLineEnd;
+                contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+            }
+            const segment = [
+                this.generatedCodeColumn,
+                sourceIndex,
+                loc.line,
+                loc.column
+            ];
+            if (nameIndex >= 0) {
+                segment.push(nameIndex);
+            }
+            this.rawSegments.push(segment);
+            this.advance(content.slice(previousContentLineEnd + 1));
+        } else if (this.pending) {
+            this.rawSegments.push(this.pending);
+            this.advance(content);
+        }
+        this.pending = null;
+    }
+    addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+        let originalCharIndex = chunk.start;
+        let first = true;
+        // when iterating each char, check if it's in a word boundary
+        let charInHiresBoundary = false;
+        while(originalCharIndex < chunk.end){
+            if (original[originalCharIndex] === '\n') {
+                loc.line += 1;
+                loc.column = 0;
+                this.generatedCodeLine += 1;
+                this.raw[this.generatedCodeLine] = this.rawSegments = [];
+                this.generatedCodeColumn = 0;
+                first = true;
+                charInHiresBoundary = false;
+            } else {
+                if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+                    const segment = [
+                        this.generatedCodeColumn,
+                        sourceIndex,
+                        loc.line,
+                        loc.column
+                    ];
+                    if (this.hires === 'boundary') {
+                        // in hires "boundary", group segments per word boundary than per char
+                        if (wordRegex.test(original[originalCharIndex])) {
+                            // for first char in the boundary found, start the boundary by pushing a segment
+                            if (!charInHiresBoundary) {
+                                this.rawSegments.push(segment);
+                                charInHiresBoundary = true;
+                            }
+                        } else {
+                            // for non-word char, end the boundary by pushing a segment
+                            this.rawSegments.push(segment);
+                            charInHiresBoundary = false;
+                        }
+                    } else {
+                        this.rawSegments.push(segment);
+                    }
+                }
+                loc.column += 1;
+                this.generatedCodeColumn += 1;
+                first = false;
+            }
+            originalCharIndex += 1;
+        }
+        this.pending = null;
+    }
+    advance(str) {
+        if (!str) return;
+        const lines = str.split('\n');
+        if (lines.length > 1) {
+            for(let i = 0; i < lines.length - 1; i++){
+                this.generatedCodeLine++;
+                this.raw[this.generatedCodeLine] = this.rawSegments = [];
+            }
+            this.generatedCodeColumn = 0;
+        }
+        this.generatedCodeColumn += lines[lines.length - 1].length;
+    }
+}
+const n = '\n';
+const warned = {
+    insertLeft: false,
+    insertRight: false,
+    storeName: false
+};
+class MagicString {
+    constructor(string, options = {}){
+        const chunk = new Chunk(0, string.length, string);
+        Object.defineProperties(this, {
+            original: {
+                writable: true,
+                value: string
+            },
+            outro: {
+                writable: true,
+                value: ''
+            },
+            intro: {
+                writable: true,
+                value: ''
+            },
+            firstChunk: {
+                writable: true,
+                value: chunk
+            },
+            lastChunk: {
+                writable: true,
+                value: chunk
+            },
+            lastSearchedChunk: {
+                writable: true,
+                value: chunk
+            },
+            byStart: {
+                writable: true,
+                value: {}
+            },
+            byEnd: {
+                writable: true,
+                value: {}
+            },
+            filename: {
+                writable: true,
+                value: options.filename
+            },
+            indentExclusionRanges: {
+                writable: true,
+                value: options.indentExclusionRanges
+            },
+            sourcemapLocations: {
+                writable: true,
+                value: new BitSet()
+            },
+            storedNames: {
+                writable: true,
+                value: {}
+            },
+            indentStr: {
+                writable: true,
+                value: undefined
+            },
+            ignoreList: {
+                writable: true,
+                value: options.ignoreList
+            },
+            offset: {
+                writable: true,
+                value: options.offset || 0
+            }
+        });
+        this.byStart[0] = chunk;
+        this.byEnd[string.length] = chunk;
+    }
+    addSourcemapLocation(char) {
+        this.sourcemapLocations.add(char);
+    }
+    append(content) {
+        if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+        this.outro += content;
+        return this;
+    }
+    appendLeft(index, content) {
+        index = index + this.offset;
+        if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+        this._split(index);
+        const chunk = this.byEnd[index];
+        if (chunk) {
+            chunk.appendLeft(content);
+        } else {
+            this.intro += content;
+        }
+        return this;
+    }
+    appendRight(index, content) {
+        index = index + this.offset;
+        if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+        this._split(index);
+        const chunk = this.byStart[index];
+        if (chunk) {
+            chunk.appendRight(content);
+        } else {
+            this.outro += content;
+        }
+        return this;
+    }
+    clone() {
+        const cloned = new MagicString(this.original, {
+            filename: this.filename,
+            offset: this.offset
+        });
+        let originalChunk = this.firstChunk;
+        let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+        while(originalChunk){
+            cloned.byStart[clonedChunk.start] = clonedChunk;
+            cloned.byEnd[clonedChunk.end] = clonedChunk;
+            const nextOriginalChunk = originalChunk.next;
+            const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+            if (nextClonedChunk) {
+                clonedChunk.next = nextClonedChunk;
+                nextClonedChunk.previous = clonedChunk;
+                clonedChunk = nextClonedChunk;
+            }
+            originalChunk = nextOriginalChunk;
+        }
+        cloned.lastChunk = clonedChunk;
+        if (this.indentExclusionRanges) {
+            cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+        }
+        cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+        cloned.intro = this.intro;
+        cloned.outro = this.outro;
+        return cloned;
+    }
+    generateDecodedMap(options) {
+        options = options || {};
+        const sourceIndex = 0;
+        const names = Object.keys(this.storedNames);
+        const mappings = new Mappings(options.hires);
+        const locate = getLocator(this.original);
+        if (this.intro) {
+            mappings.advance(this.intro);
+        }
+        this.firstChunk.eachNext((chunk)=>{
+            const loc = locate(chunk.start);
+            if (chunk.intro.length) mappings.advance(chunk.intro);
+            if (chunk.edited) {
+                mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+            } else {
+                mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+            }
+            if (chunk.outro.length) mappings.advance(chunk.outro);
+        });
+        return {
+            file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+            sources: [
+                options.source ? getRelativePath(options.file || '', options.source) : options.file || ''
+            ],
+            sourcesContent: options.includeContent ? [
+                this.original
+            ] : undefined,
+            names,
+            mappings: mappings.raw,
+            x_google_ignoreList: this.ignoreList ? [
+                sourceIndex
+            ] : undefined
+        };
+    }
+    generateMap(options) {
+        return new SourceMap(this.generateDecodedMap(options));
+    }
+    _ensureindentStr() {
+        if (this.indentStr === undefined) {
+            this.indentStr = guessIndent(this.original);
+        }
+    }
+    _getRawIndentString() {
+        this._ensureindentStr();
+        return this.indentStr;
+    }
+    getIndentString() {
+        this._ensureindentStr();
+        return this.indentStr === null ? '\t' : this.indentStr;
+    }
+    indent(indentStr, options) {
+        const pattern = /^[^\r\n]/gm;
+        if (isObject(indentStr)) {
+            options = indentStr;
+            indentStr = undefined;
+        }
+        if (indentStr === undefined) {
+            this._ensureindentStr();
+            indentStr = this.indentStr || '\t';
+        }
+        if (indentStr === '') return this; // noop
+        options = options || {};
+        // Process exclusion ranges
+        const isExcluded = {};
+        if (options.exclude) {
+            const exclusions = typeof options.exclude[0] === 'number' ? [
+                options.exclude
+            ] : options.exclude;
+            exclusions.forEach((exclusion)=>{
+                for(let i = exclusion[0]; i < exclusion[1]; i += 1){
+                    isExcluded[i] = true;
+                }
+            });
+        }
+        let shouldIndentNextCharacter = options.indentStart !== false;
+        const replacer = (match)=>{
+            if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+            shouldIndentNextCharacter = true;
+            return match;
+        };
+        this.intro = this.intro.replace(pattern, replacer);
+        let charIndex = 0;
+        let chunk = this.firstChunk;
+        while(chunk){
+            const end = chunk.end;
+            if (chunk.edited) {
+                if (!isExcluded[charIndex]) {
+                    chunk.content = chunk.content.replace(pattern, replacer);
+                    if (chunk.content.length) {
+                        shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+                    }
+                }
+            } else {
+                charIndex = chunk.start;
+                while(charIndex < end){
+                    if (!isExcluded[charIndex]) {
+                        const char = this.original[charIndex];
+                        if (char === '\n') {
+                            shouldIndentNextCharacter = true;
+                        } else if (char !== '\r' && shouldIndentNextCharacter) {
+                            shouldIndentNextCharacter = false;
+                            if (charIndex === chunk.start) {
+                                chunk.prependRight(indentStr);
+                            } else {
+                                this._splitChunk(chunk, charIndex);
+                                chunk = chunk.next;
+                                chunk.prependRight(indentStr);
+                            }
+                        }
+                    }
+                    charIndex += 1;
+                }
+            }
+            charIndex = chunk.end;
+            chunk = chunk.next;
+        }
+        this.outro = this.outro.replace(pattern, replacer);
+        return this;
+    }
+    insert() {
+        throw new Error('magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)');
+    }
+    insertLeft(index, content) {
+        if (!warned.insertLeft) {
+            console.warn('magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead');
+            warned.insertLeft = true;
+        }
+        return this.appendLeft(index, content);
+    }
+    insertRight(index, content) {
+        if (!warned.insertRight) {
+            console.warn('magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead');
+            warned.insertRight = true;
+        }
+        return this.prependRight(index, content);
+    }
+    move(start, end, index) {
+        start = start + this.offset;
+        end = end + this.offset;
+        index = index + this.offset;
+        if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+        this._split(start);
+        this._split(end);
+        this._split(index);
+        const first = this.byStart[start];
+        const last = this.byEnd[end];
+        const oldLeft = first.previous;
+        const oldRight = last.next;
+        const newRight = this.byStart[index];
+        if (!newRight && last === this.lastChunk) return this;
+        const newLeft = newRight ? newRight.previous : this.lastChunk;
+        if (oldLeft) oldLeft.next = oldRight;
+        if (oldRight) oldRight.previous = oldLeft;
+        if (newLeft) newLeft.next = first;
+        if (newRight) newRight.previous = last;
+        if (!first.previous) this.firstChunk = last.next;
+        if (!last.next) {
+            this.lastChunk = first.previous;
+            this.lastChunk.next = null;
+        }
+        first.previous = newLeft;
+        last.next = newRight || null;
+        if (!newLeft) this.firstChunk = first;
+        if (!newRight) this.lastChunk = last;
+        return this;
+    }
+    overwrite(start, end, content, options) {
+        options = options || {};
+        return this.update(start, end, content, {
+            ...options,
+            overwrite: !options.contentOnly
+        });
+    }
+    update(start, end, content, options) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+        if (this.original.length !== 0) {
+            while(start < 0)start += this.original.length;
+            while(end < 0)end += this.original.length;
+        }
+        if (end > this.original.length) throw new Error('end is out of bounds');
+        if (start === end) throw new Error('Cannot overwrite a zero-length range – use appendLeft or prependRight instead');
+        this._split(start);
+        this._split(end);
+        if (options === true) {
+            if (!warned.storeName) {
+                console.warn('The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string');
+                warned.storeName = true;
+            }
+            options = {
+                storeName: true
+            };
+        }
+        const storeName = options !== undefined ? options.storeName : false;
+        const overwrite = options !== undefined ? options.overwrite : false;
+        if (storeName) {
+            const original = this.original.slice(start, end);
+            Object.defineProperty(this.storedNames, original, {
+                writable: true,
+                value: true,
+                enumerable: true
+            });
+        }
+        const first = this.byStart[start];
+        const last = this.byEnd[end];
+        if (first) {
+            let chunk = first;
+            while(chunk !== last){
+                if (chunk.next !== this.byStart[chunk.end]) {
+                    throw new Error('Cannot overwrite across a split point');
+                }
+                chunk = chunk.next;
+                chunk.edit('', false);
+            }
+            first.edit(content, storeName, !overwrite);
+        } else {
+            // must be inserting at the end
+            const newChunk = new Chunk(start, end, '').edit(content, storeName);
+            // TODO last chunk in the array may not be the last chunk, if it's moved...
+            last.next = newChunk;
+            newChunk.previous = last;
+        }
+        return this;
+    }
+    prepend(content) {
+        if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+        this.intro = content + this.intro;
+        return this;
+    }
+    prependLeft(index, content) {
+        index = index + this.offset;
+        if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+        this._split(index);
+        const chunk = this.byEnd[index];
+        if (chunk) {
+            chunk.prependLeft(content);
+        } else {
+            this.intro = content + this.intro;
+        }
+        return this;
+    }
+    prependRight(index, content) {
+        index = index + this.offset;
+        if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+        this._split(index);
+        const chunk = this.byStart[index];
+        if (chunk) {
+            chunk.prependRight(content);
+        } else {
+            this.outro = content + this.outro;
+        }
+        return this;
+    }
+    remove(start, end) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+            while(start < 0)start += this.original.length;
+            while(end < 0)end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+        if (start > end) throw new Error('end must be greater than start');
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while(chunk){
+            chunk.intro = '';
+            chunk.outro = '';
+            chunk.edit('');
+            chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+    }
+    reset(start, end) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+            while(start < 0)start += this.original.length;
+            while(end < 0)end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+        if (start > end) throw new Error('end must be greater than start');
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while(chunk){
+            chunk.reset();
+            chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+    }
+    lastChar() {
+        if (this.outro.length) return this.outro[this.outro.length - 1];
+        let chunk = this.lastChunk;
+        do {
+            if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+            if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+            if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+        }while (chunk = chunk.previous)
+        if (this.intro.length) return this.intro[this.intro.length - 1];
+        return '';
+    }
+    lastLine() {
+        let lineIndex = this.outro.lastIndexOf(n);
+        if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+        let lineStr = this.outro;
+        let chunk = this.lastChunk;
+        do {
+            if (chunk.outro.length > 0) {
+                lineIndex = chunk.outro.lastIndexOf(n);
+                if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.outro + lineStr;
+            }
+            if (chunk.content.length > 0) {
+                lineIndex = chunk.content.lastIndexOf(n);
+                if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.content + lineStr;
+            }
+            if (chunk.intro.length > 0) {
+                lineIndex = chunk.intro.lastIndexOf(n);
+                if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.intro + lineStr;
+            }
+        }while (chunk = chunk.previous)
+        lineIndex = this.intro.lastIndexOf(n);
+        if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+        return this.intro + lineStr;
+    }
+    slice(start = 0, end = this.original.length - this.offset) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+            while(start < 0)start += this.original.length;
+            while(end < 0)end += this.original.length;
+        }
+        let result = '';
+        // find start chunk
+        let chunk = this.firstChunk;
+        while(chunk && (chunk.start > start || chunk.end <= start)){
+            // found end chunk before start
+            if (chunk.start < end && chunk.end >= end) {
+                return result;
+            }
+            chunk = chunk.next;
+        }
+        if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+        const startChunk = chunk;
+        while(chunk){
+            if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+                result += chunk.intro;
+            }
+            const containsEnd = chunk.start < end && chunk.end >= end;
+            if (containsEnd && chunk.edited && chunk.end !== end) throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+            const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+            const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+            result += chunk.content.slice(sliceStart, sliceEnd);
+            if (chunk.outro && (!containsEnd || chunk.end === end)) {
+                result += chunk.outro;
+            }
+            if (containsEnd) {
+                break;
+            }
+            chunk = chunk.next;
+        }
+        return result;
+    }
+    // TODO deprecate this? not really very useful
+    snip(start, end) {
+        const clone = this.clone();
+        clone.remove(0, start);
+        clone.remove(end, clone.original.length);
+        return clone;
+    }
+    _split(index) {
+        if (this.byStart[index] || this.byEnd[index]) return;
+        let chunk = this.lastSearchedChunk;
+        const searchForward = index > chunk.end;
+        while(chunk){
+            if (chunk.contains(index)) return this._splitChunk(chunk, index);
+            chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+        }
+    }
+    _splitChunk(chunk, index) {
+        if (chunk.edited && chunk.content.length) {
+            // zero-length edited chunks are a special case (overlapping replacements)
+            const loc = getLocator(this.original)(index);
+            throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+        }
+        const newChunk = chunk.split(index);
+        this.byEnd[index] = chunk;
+        this.byStart[index] = newChunk;
+        this.byEnd[newChunk.end] = newChunk;
+        if (chunk === this.lastChunk) this.lastChunk = newChunk;
+        this.lastSearchedChunk = chunk;
+        return true;
+    }
+    toString() {
+        let str = this.intro;
+        let chunk = this.firstChunk;
+        while(chunk){
+            str += chunk.toString();
+            chunk = chunk.next;
+        }
+        return str + this.outro;
+    }
+    isEmpty() {
+        let chunk = this.firstChunk;
+        do {
+            if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+        }while (chunk = chunk.next)
+        return true;
+    }
+    length() {
+        let chunk = this.firstChunk;
+        let length = 0;
+        do {
+            length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+        }while (chunk = chunk.next)
+        return length;
+    }
+    trimLines() {
+        return this.trim('[\\r\\n]');
+    }
+    trim(charType) {
+        return this.trimStart(charType).trimEnd(charType);
+    }
+    trimEndAborted(charType) {
+        const rx = new RegExp((charType || '\\s') + '+$');
+        this.outro = this.outro.replace(rx, '');
+        if (this.outro.length) return true;
+        let chunk = this.lastChunk;
+        do {
+            const end = chunk.end;
+            const aborted = chunk.trimEnd(rx);
+            // if chunk was trimmed, we have a new lastChunk
+            if (chunk.end !== end) {
+                if (this.lastChunk === chunk) {
+                    this.lastChunk = chunk.next;
+                }
+                this.byEnd[chunk.end] = chunk;
+                this.byStart[chunk.next.start] = chunk.next;
+                this.byEnd[chunk.next.end] = chunk.next;
+            }
+            if (aborted) return true;
+            chunk = chunk.previous;
+        }while (chunk)
+        return false;
+    }
+    trimEnd(charType) {
+        this.trimEndAborted(charType);
+        return this;
+    }
+    trimStartAborted(charType) {
+        const rx = new RegExp('^' + (charType || '\\s') + '+');
+        this.intro = this.intro.replace(rx, '');
+        if (this.intro.length) return true;
+        let chunk = this.firstChunk;
+        do {
+            const end = chunk.end;
+            const aborted = chunk.trimStart(rx);
+            if (chunk.end !== end) {
+                // special case...
+                if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+                this.byEnd[chunk.end] = chunk;
+                this.byStart[chunk.next.start] = chunk.next;
+                this.byEnd[chunk.next.end] = chunk.next;
+            }
+            if (aborted) return true;
+            chunk = chunk.next;
+        }while (chunk)
+        return false;
+    }
+    trimStart(charType) {
+        this.trimStartAborted(charType);
+        return this;
+    }
+    hasChanged() {
+        return this.original !== this.toString();
+    }
+    _replaceRegexp(searchValue, replacement) {
+        function getReplacement(match, str) {
+            if (typeof replacement === 'string') {
+                return replacement.replace(/\$(\$|&|\d+)/g, (_, i)=>{
+                    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+                    if (i === '$') return '$';
+                    if (i === '&') return match[0];
+                    const num = +i;
+                    if (num < match.length) return match[+i];
+                    return `$${i}`;
+                });
+            } else {
+                return replacement(...match, match.index, str, match.groups);
+            }
+        }
+        function matchAll(re, str) {
+            let match;
+            const matches = [];
+            while(match = re.exec(str)){
+                matches.push(match);
+            }
+            return matches;
+        }
+        if (searchValue.global) {
+            const matches = matchAll(searchValue, this.original);
+            matches.forEach((match)=>{
+                if (match.index != null) {
+                    const replacement = getReplacement(match, this.original);
+                    if (replacement !== match[0]) {
+                        this.overwrite(match.index, match.index + match[0].length, replacement);
+                    }
+                }
+            });
+        } else {
+            const match = this.original.match(searchValue);
+            if (match && match.index != null) {
+                const replacement = getReplacement(match, this.original);
+                if (replacement !== match[0]) {
+                    this.overwrite(match.index, match.index + match[0].length, replacement);
+                }
+            }
+        }
+        return this;
+    }
+    _replaceString(string, replacement) {
+        const { original } = this;
+        const index = original.indexOf(string);
+        if (index !== -1) {
+            this.overwrite(index, index + string.length, replacement);
+        }
+        return this;
+    }
+    replace(searchValue, replacement) {
+        if (typeof searchValue === 'string') {
+            return this._replaceString(searchValue, replacement);
+        }
+        return this._replaceRegexp(searchValue, replacement);
+    }
+    _replaceAllString(string, replacement) {
+        const { original } = this;
+        const stringLength = string.length;
+        for(let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)){
+            const previous = original.slice(index, index + stringLength);
+            if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+        }
+        return this;
+    }
+    replaceAll(searchValue, replacement) {
+        if (typeof searchValue === 'string') {
+            return this._replaceAllString(searchValue, replacement);
+        }
+        if (!searchValue.global) {
+            throw new TypeError('MagicString.prototype.replaceAll called with a non-global RegExp argument');
+        }
+        return this._replaceRegexp(searchValue, replacement);
+    }
+}
+
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+function decodeComponents(components, split) {
+    try {
+        // Try to decode the entire string first
+        return [
+            decodeURIComponent(components.join(''))
+        ];
+    } catch  {
+    // Do nothing
+    }
+    if (components.length === 1) {
+        return components;
+    }
+    split = split || 1;
+    // Split the array in 2 parts
+    const left = components.slice(0, split);
+    const right = components.slice(split);
+    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode$1(input) {
+    try {
+        return decodeURIComponent(input);
+    } catch  {
+        let tokens = input.match(singleMatcher) || [];
+        for(let i = 1; i < tokens.length; i++){
+            input = decodeComponents(tokens, i).join('');
+            tokens = input.match(singleMatcher) || [];
+        }
+        return input;
+    }
+}
+function customDecodeURIComponent(input) {
+    // Keep track of all the replacements and prefill the map with the `BOM`
+    const replaceMap = {
+        '%FE%FF': '\uFFFD\uFFFD',
+        '%FF%FE': '\uFFFD\uFFFD'
+    };
+    let match = multiMatcher.exec(input);
+    while(match){
+        try {
+            // Decode as big chunks as possible
+            replaceMap[match[0]] = decodeURIComponent(match[0]);
+        } catch  {
+            const result = decode$1(match[0]);
+            if (result !== match[0]) {
+                replaceMap[match[0]] = result;
+            }
+        }
+        match = multiMatcher.exec(input);
+    }
+    // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+    replaceMap['%C2'] = '\uFFFD';
+    const entries = Object.keys(replaceMap);
+    for (const key of entries){
+        // Replace all decoded components
+        input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+    }
+    return input;
+}
+function decodeUriComponent(encodedURI) {
+    if (typeof encodedURI !== 'string') {
+        throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+    }
+    try {
+        // Try the built in decoder first
+        return decodeURIComponent(encodedURI);
+    } catch  {
+        // Fallback to a more advanced decoder
+        return customDecodeURIComponent(encodedURI);
+    }
+}
+
+function includeKeys(object, predicate) {
+    const result = {};
+    if (Array.isArray(predicate)) {
+        for (const key of predicate){
+            const descriptor = Object.getOwnPropertyDescriptor(object, key);
+            if (descriptor?.enumerable) {
+                Object.defineProperty(result, key, descriptor);
+            }
+        }
+    } else {
+        // `Reflect.ownKeys()` is required to retrieve symbol properties
+        for (const key of Reflect.ownKeys(object)){
+            const descriptor = Object.getOwnPropertyDescriptor(object, key);
+            if (descriptor.enumerable) {
+                const value = object[key];
+                if (predicate(key, value, object)) {
+                    Object.defineProperty(result, key, descriptor);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+function splitOnFirst(string, separator) {
+    if (!(typeof string === 'string' && typeof separator === 'string')) {
+        throw new TypeError('Expected the arguments to be of type `string`');
+    }
+    if (string === '' || separator === '') {
+        return [];
+    }
+    const separatorIndex = string.indexOf(separator);
+    if (separatorIndex === -1) {
+        return [];
+    }
+    return [
+        string.slice(0, separatorIndex),
+        string.slice(separatorIndex + separator.length)
+    ];
+}
+
+const isNullOrUndefined = (value)=>value === null || value === undefined;
+// eslint-disable-next-line unicorn/prefer-code-point
+const strictUriEncode = (string)=>encodeURIComponent(string).replaceAll(/[!'()*]/g, (x)=>`%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+const encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');
+function encoderForArrayFormat(options) {
+    switch(options.arrayFormat){
+        case 'index':
+            {
+                return (key)=>(result, value)=>{
+                        const index = result.length;
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+                            return result;
+                        }
+                        if (value === null) {
+                            return [
+                                ...result,
+                                [
+                                    encode(key, options),
+                                    '[',
+                                    index,
+                                    ']'
+                                ].join('')
+                            ];
+                        }
+                        return [
+                            ...result,
+                            [
+                                encode(key, options),
+                                '[',
+                                encode(index, options),
+                                ']=',
+                                encode(value, options)
+                            ].join('')
+                        ];
+                    };
+            }
+        case 'bracket':
+            {
+                return (key)=>(result, value)=>{
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+                            return result;
+                        }
+                        if (value === null) {
+                            return [
+                                ...result,
+                                [
+                                    encode(key, options),
+                                    '[]'
+                                ].join('')
+                            ];
+                        }
+                        return [
+                            ...result,
+                            [
+                                encode(key, options),
+                                '[]=',
+                                encode(value, options)
+                            ].join('')
+                        ];
+                    };
+            }
+        case 'colon-list-separator':
+            {
+                return (key)=>(result, value)=>{
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+                            return result;
+                        }
+                        if (value === null) {
+                            return [
+                                ...result,
+                                [
+                                    encode(key, options),
+                                    ':list='
+                                ].join('')
+                            ];
+                        }
+                        return [
+                            ...result,
+                            [
+                                encode(key, options),
+                                ':list=',
+                                encode(value, options)
+                            ].join('')
+                        ];
+                    };
+            }
+        case 'comma':
+        case 'separator':
+        case 'bracket-separator':
+            {
+                const keyValueSeparator = options.arrayFormat === 'bracket-separator' ? '[]=' : '=';
+                return (key)=>(result, value)=>{
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+                            return result;
+                        }
+                        // Translate null to an empty string so that it doesn't serialize as 'null'
+                        value = value === null ? '' : value;
+                        if (result.length === 0) {
+                            return [
+                                [
+                                    encode(key, options),
+                                    keyValueSeparator,
+                                    encode(value, options)
+                                ].join('')
+                            ];
+                        }
+                        return [
+                            [
+                                result,
+                                encode(value, options)
+                            ].join(options.arrayFormatSeparator)
+                        ];
+                    };
+            }
+        default:
+            {
+                return (key)=>(result, value)=>{
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {
+                            return result;
+                        }
+                        if (value === null) {
+                            return [
+                                ...result,
+                                encode(key, options)
+                            ];
+                        }
+                        return [
+                            ...result,
+                            [
+                                encode(key, options),
+                                '=',
+                                encode(value, options)
+                            ].join('')
+                        ];
+                    };
+            }
+    }
+}
+function parserForArrayFormat(options) {
+    let result;
+    switch(options.arrayFormat){
+        case 'index':
+            {
+                return (key, value, accumulator)=>{
+                    result = /\[(\d*)]$/.exec(key);
+                    key = key.replace(/\[\d*]$/, '');
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = {};
+                    }
+                    accumulator[key][result[1]] = value;
+                };
+            }
+        case 'bracket':
+            {
+                return (key, value, accumulator)=>{
+                    result = /(\[])$/.exec(key);
+                    key = key.replace(/\[]$/, '');
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = [
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key] = [
+                        ...accumulator[key],
+                        value
+                    ];
+                };
+            }
+        case 'colon-list-separator':
+            {
+                return (key, value, accumulator)=>{
+                    result = /(:list)$/.exec(key);
+                    key = key.replace(/:list$/, '');
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = [
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key] = [
+                        ...accumulator[key],
+                        value
+                    ];
+                };
+            }
+        case 'comma':
+        case 'separator':
+            {
+                return (key, value, accumulator)=>{
+                    const isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
+                    const isEncodedArray = typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
+                    value = isEncodedArray ? decode(value, options) : value;
+                    const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item)=>decode(item, options)) : value === null ? value : decode(value, options);
+                    accumulator[key] = newValue;
+                };
+            }
+        case 'bracket-separator':
+            {
+                return (key, value, accumulator)=>{
+                    const isArray = /(\[])$/.test(key);
+                    key = key.replace(/\[]$/, '');
+                    if (!isArray) {
+                        accumulator[key] = value ? decode(value, options) : value;
+                        return;
+                    }
+                    const arrayValue = value === null ? [] : decode(value, options).split(options.arrayFormatSeparator);
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = arrayValue;
+                        return;
+                    }
+                    accumulator[key] = [
+                        ...accumulator[key],
+                        ...arrayValue
+                    ];
+                };
+            }
+        default:
+            {
+                return (key, value, accumulator)=>{
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    accumulator[key] = [
+                        ...[
+                            accumulator[key]
+                        ].flat(),
+                        value
+                    ];
+                };
+            }
+    }
+}
+function validateArrayFormatSeparator(value) {
+    if (typeof value !== 'string' || value.length !== 1) {
+        throw new TypeError('arrayFormatSeparator must be single character string');
+    }
+}
+function encode(value, options) {
+    if (options.encode) {
+        return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+    }
+    return value;
+}
+function decode(value, options) {
+    if (options.decode) {
+        return decodeUriComponent(value);
+    }
+    return value;
+}
+function keysSorter(input) {
+    if (Array.isArray(input)) {
+        return input.sort();
+    }
+    if (typeof input === 'object') {
+        return keysSorter(Object.keys(input)).sort((a, b)=>Number(a) - Number(b)).map((key)=>input[key]);
+    }
+    return input;
+}
+function removeHash(input) {
+    const hashStart = input.indexOf('#');
+    if (hashStart !== -1) {
+        input = input.slice(0, hashStart);
+    }
+    return input;
+}
+function getHash(url) {
+    let hash = '';
+    const hashStart = url.indexOf('#');
+    if (hashStart !== -1) {
+        hash = url.slice(hashStart);
+    }
+    return hash;
+}
+function parseValue(value, options, type) {
+    if (type === 'string' && typeof value === 'string') {
+        return value;
+    }
+    if (typeof type === 'function' && typeof value === 'string') {
+        return type(value);
+    }
+    if (type === 'boolean' && value === null) {
+        return true;
+    }
+    if (type === 'boolean' && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+        return value.toLowerCase() === 'true';
+    }
+    if (type === 'boolean' && value !== null && (value.toLowerCase() === '1' || value.toLowerCase() === '0')) {
+        return value.toLowerCase() === '1';
+    }
+    if (type === 'string[]' && options.arrayFormat !== 'none' && typeof value === 'string') {
+        return [
+            value
+        ];
+    }
+    if (type === 'number[]' && options.arrayFormat !== 'none' && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+        return [
+            Number(value)
+        ];
+    }
+    if (type === 'number' && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+        return Number(value);
+    }
+    if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+        return value.toLowerCase() === 'true';
+    }
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
+        return Number(value);
+    }
+    return value;
+}
+function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf('?');
+    if (queryStart === -1) {
+        return '';
+    }
+    return input.slice(queryStart + 1);
+}
+function parse(query, options) {
+    options = {
+        decode: true,
+        sort: true,
+        arrayFormat: 'none',
+        arrayFormatSeparator: ',',
+        parseNumbers: false,
+        parseBooleans: false,
+        types: Object.create(null),
+        ...options
+    };
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+    // Create an object with no prototype
+    const returnValue = Object.create(null);
+    if (typeof query !== 'string') {
+        return returnValue;
+    }
+    query = query.trim().replace(/^[?#&]/, '');
+    if (!query) {
+        return returnValue;
+    }
+    for (const parameter of query.split('&')){
+        if (parameter === '') {
+            continue;
+        }
+        const parameter_ = options.decode ? parameter.replaceAll('+', ' ') : parameter;
+        let [key, value] = splitOnFirst(parameter_, '=');
+        if (key === undefined) {
+            key = parameter_;
+        }
+        // Missing `=` should be `null`:
+        // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+        value = value === undefined ? null : [
+            'comma',
+            'separator',
+            'bracket-separator'
+        ].includes(options.arrayFormat) ? value : decode(value, options);
+        formatter(decode(key, options), value, returnValue);
+    }
+    for (const [key, value] of Object.entries(returnValue)){
+        if (typeof value === 'object' && value !== null && options.types[key] !== 'string') {
+            for (const [key2, value2] of Object.entries(value)){
+                const type = options.types[key] ? options.types[key].replace('[]', '') : undefined;
+                value[key2] = parseValue(value2, options, type);
+            }
+        } else if (typeof value === 'object' && value !== null && options.types[key] === 'string') {
+            returnValue[key] = Object.values(value).join(options.arrayFormatSeparator);
+        } else {
+            returnValue[key] = parseValue(value, options, options.types[key]);
+        }
+    }
+    if (options.sort === false) {
+        return returnValue;
+    }
+    // TODO: Remove the use of `reduce`.
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce((result, key)=>{
+        const value = returnValue[key];
+        result[key] = Boolean(value) && typeof value === 'object' && !Array.isArray(value) ? keysSorter(value) : value;
+        return result;
+    }, Object.create(null));
+}
+function stringify(object, options) {
+    if (!object) {
+        return '';
+    }
+    options = {
+        encode: true,
+        strict: true,
+        arrayFormat: 'none',
+        arrayFormatSeparator: ',',
+        ...options
+    };
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = (key)=>options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === '';
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const [key, value] of Object.entries(object)){
+        if (!shouldFilter(key)) {
+            objectCopy[key] = value;
+        }
+    }
+    const keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+        keys.sort(options.sort);
+    }
+    return keys.map((key)=>{
+        const value = object[key];
+        if (value === undefined) {
+            return '';
+        }
+        if (value === null) {
+            return encode(key, options);
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0 && options.arrayFormat === 'bracket-separator') {
+                return encode(key, options) + '[]';
+            }
+            return value.reduce(formatter(key), []).join('&');
+        }
+        return encode(key, options) + '=' + encode(value, options);
+    }).filter((x)=>x.length > 0).join('&');
+}
+function parseUrl(url, options) {
+    options = {
+        decode: true,
+        ...options
+    };
+    let [url_, hash] = splitOnFirst(url, '#');
+    if (url_ === undefined) {
+        url_ = url;
+    }
+    return {
+        url: url_?.split('?')?.[0] ?? '',
+        query: parse(extract(url), options),
+        ...options && options.parseFragmentIdentifier && hash ? {
+            fragmentIdentifier: decode(hash, options)
+        } : {}
+    };
+}
+function stringifyUrl(object, options) {
+    options = {
+        encode: true,
+        strict: true,
+        [encodeFragmentIdentifier]: true,
+        ...options
+    };
+    const url = removeHash(object.url).split('?')[0] || '';
+    const queryFromUrl = extract(object.url);
+    const query = {
+        ...parse(queryFromUrl, {
+            sort: false,
+            ...options
+        }),
+        ...object.query
+    };
+    let queryString = stringify(query, options);
+    queryString &&= `?${queryString}`;
+    let hash = getHash(object.url);
+    if (typeof object.fragmentIdentifier === 'string') {
+        const urlObjectForFragmentEncode = new URL(url);
+        urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+        hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : `#${object.fragmentIdentifier}`;
+    }
+    return `${url}${queryString}${hash}`;
+}
+function pick(input, filter, options) {
+    options = {
+        parseFragmentIdentifier: true,
+        [encodeFragmentIdentifier]: false,
+        ...options
+    };
+    const { url, query, fragmentIdentifier } = parseUrl(input, options);
+    return stringifyUrl({
+        url,
+        query: includeKeys(query, filter),
+        fragmentIdentifier
+    }, options);
+}
+function exclude(input, filter, options) {
+    const exclusionFilter = Array.isArray(filter) ? (key)=>!filter.includes(key) : (key, value)=>!filter(key, value);
+    return pick(input, exclusionFilter, options);
+}
+
+var queryString = {
+  __proto__: null,
+  exclude: exclude,
+  extract: extract,
+  parse: parse,
+  parseUrl: parseUrl,
+  pick: pick,
+  stringify: stringify,
+  stringifyUrl: stringifyUrl
+};
+
+var postcssNextFont = {};
+
+var hasRequiredPostcssNextFont;
+
+function requirePostcssNextFont () {
+	if (hasRequiredPostcssNextFont) return postcssNextFont;
+	hasRequiredPostcssNextFont = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "default", {
+		    enumerable: true,
+		    get: function() {
+		        return _default;
+		    }
+		});
+		const _postcss = /*#__PURE__*/ _interop_require_default(require$$0$1);
+		function _interop_require_default(obj) {
+		    return obj && obj.__esModule ? obj : {
+		        default: obj
+		    };
+		}
+		/**
+		 * The next/font postcss plugin receives the @font-face declarations returned from the next/font loaders.
+		 *
+		 * It hashes the font-family name to make it unguessable, it shouldn't be globally accessible.
+		 * If it were global, we wouldn't be able to tell which pages are using which fonts when generating preload tags.
+		 *
+		 * If the font loader returned fallback metrics, generate a fallback @font-face.
+		 *
+		 * If the font loader returned a variable name, add a CSS class that declares a variable containing the font and fallback fonts.
+		 *
+		 * Lastly, it adds the font-family to the exports object.
+		 * This enables you to access the actual font-family name, not just through the CSS class.
+		 * e.g:
+		 * const inter = Inter({ subsets: ['latin'] })
+		 * inter.style.fontFamily // => '__Inter_123456'
+		 */ const postcssNextFontPlugin = ({ exports: exports1, fallbackFonts = [], adjustFontFallback, variable, weight, style })=>{
+		    return {
+		        postcssPlugin: 'postcss-next-font',
+		        Once (root) {
+		            let fontFamily;
+		            const normalizeFamily = (family)=>{
+		                return family.replace(/['"]/g, '');
+		            };
+		            const formatFamily = (family)=>{
+		                return `'${family}'`;
+		            };
+		            // Hash font-family names
+		            for (const node of root.nodes){
+		                if (node.type === 'atrule' && node.name === 'font-face') {
+		                    const familyNode = node.nodes.find((decl)=>decl.prop === 'font-family');
+		                    if (!familyNode) {
+		                        continue;
+		                    }
+		                    if (!fontFamily) {
+		                        fontFamily = normalizeFamily(familyNode.value);
+		                    }
+		                    familyNode.value = formatFamily(fontFamily);
+		                }
+		            }
+		            if (!fontFamily) {
+		                throw Object.defineProperty(new Error("Font loaders must return one or more @font-face's"), "__NEXT_ERROR_CODE", {
+		                    value: "E428",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            }
+		            // Add fallback @font-face with the provided override values
+		            let adjustFontFallbackFamily;
+		            if (adjustFontFallback) {
+		                adjustFontFallbackFamily = formatFamily(`${fontFamily} Fallback`);
+		                const fallbackFontFace = _postcss.default.atRule({
+		                    name: 'font-face'
+		                });
+		                const { fallbackFont, ascentOverride, descentOverride, lineGapOverride, sizeAdjust } = adjustFontFallback;
+		                fallbackFontFace.nodes = [
+		                    new _postcss.default.Declaration({
+		                        prop: 'font-family',
+		                        value: adjustFontFallbackFamily
+		                    }),
+		                    new _postcss.default.Declaration({
+		                        prop: 'src',
+		                        value: `local("${fallbackFont}")`
+		                    }),
+		                    ...ascentOverride ? [
+		                        new _postcss.default.Declaration({
+		                            prop: 'ascent-override',
+		                            value: ascentOverride
+		                        })
+		                    ] : [],
+		                    ...descentOverride ? [
+		                        new _postcss.default.Declaration({
+		                            prop: 'descent-override',
+		                            value: descentOverride
+		                        })
+		                    ] : [],
+		                    ...lineGapOverride ? [
+		                        new _postcss.default.Declaration({
+		                            prop: 'line-gap-override',
+		                            value: lineGapOverride
+		                        })
+		                    ] : [],
+		                    ...sizeAdjust ? [
+		                        new _postcss.default.Declaration({
+		                            prop: 'size-adjust',
+		                            value: sizeAdjust
+		                        })
+		                    ] : []
+		                ];
+		                root.nodes.push(fallbackFontFace);
+		            }
+		            // Variable fonts can define ranges of values
+		            const isRange = (value)=>value.trim().includes(' ');
+		            // Format the font families to be used in the CSS
+		            const formattedFontFamilies = [
+		                formatFamily(fontFamily),
+		                ...adjustFontFallbackFamily ? [
+		                    adjustFontFallbackFamily
+		                ] : [],
+		                ...fallbackFonts
+		            ].join(', ');
+		            // Add class with family, weight and style
+		            const classRule = new _postcss.default.Rule({
+		                selector: '.className'
+		            });
+		            classRule.nodes = [
+		                new _postcss.default.Declaration({
+		                    prop: 'font-family',
+		                    value: formattedFontFamilies
+		                }),
+		                // If the font only has one weight or style, we can set it on the class
+		                ...weight && !isRange(weight) ? [
+		                    new _postcss.default.Declaration({
+		                        prop: 'font-weight',
+		                        value: weight
+		                    })
+		                ] : [],
+		                ...style && !isRange(style) ? [
+		                    new _postcss.default.Declaration({
+		                        prop: 'font-style',
+		                        value: style
+		                    })
+		                ] : []
+		            ];
+		            root.nodes.push(classRule);
+		            // Add CSS class that defines a variable with the font families
+		            if (variable) {
+		                const varialbeRule = new _postcss.default.Rule({
+		                    selector: '.variable'
+		                });
+		                varialbeRule.nodes = [
+		                    new _postcss.default.Declaration({
+		                        prop: variable,
+		                        value: formattedFontFamilies
+		                    })
+		                ];
+		                root.nodes.push(varialbeRule);
+		            }
+		            // Export @font-face values as is
+		            exports1.push({
+		                name: 'style',
+		                value: {
+		                    fontFamily: formattedFontFamilies,
+		                    fontWeight: !Number.isNaN(Number(weight)) ? Number(weight) : undefined,
+		                    fontStyle: style && !isRange(style) ? style : undefined
+		                }
+		            });
+		        }
+		    };
+		};
+		postcssNextFontPlugin.postcss = true;
+		const _default = postcssNextFontPlugin; 
+	} (postcssNextFont));
+	return postcssNextFont;
+}
+
+var postcssNextFontExports = requirePostcssNextFont();
+var postcssNextFontPlugin = /*@__PURE__*/getDefaultExportFromCjs(postcssNextFontExports);
+
+const getQuerySuffix = (id)=>{
+    const queryStart = id.indexOf('?');
+    if (queryStart === -1) {
+        return '';
+    }
+    return id.slice(queryStart);
+};
+const removeQuerySuffix = (id)=>{
+    const queryStart = id.indexOf('?');
+    if (queryStart === -1) {
+        return id;
+    }
+    return id.slice(0, queryStart);
+};
+const createCachedImport = (imp)=>{
+    let cached;
+    return ()=>{
+        if (!cached) {
+            cached = imp().then((module)=>{
+                cached = module;
+                return module;
+            });
+        }
+        return cached;
+    };
+};
+// Main wrapper function
+const tryCatch = async (promise)=>{
+    try {
+        const data = await promise;
+        return {
+            data,
+            error: null
+        };
+    } catch (error) {
+        return {
+            data: null,
+            error: error
+        };
+    }
+};
+const importResolve = async (id)=>import.meta.resolve(removeQuerySuffix(id));
+/**
+ * Encodes the URI path portion (ignores part after ? or #)
+ */ function encodeURIPath(uri) {
+    if (uri.startsWith('data:')) return uri;
+    const filePath = cleanUrl(uri);
+    const postfix = filePath !== uri ? uri.slice(filePath.length) : '';
+    return encodeURI(filePath) + postfix;
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+    return url.replace(postfixRE, '');
+}
+const fontNameToUrl = (fontName)=>{
+    return [
+        ''
+    ].concat([
+        '_next',
+        fontName
+    ].filter(Boolean)).join('/');
+};
+const normalizeTargetCssId = (id)=>{
+    return queryString.stringifyUrl({
+        url: removeQuerySuffix(id),
+        query: pickKeys(queryString.parse(getQuerySuffix(id)), [
+            'arguments',
+            'path',
+            'import',
+            'variableName'
+        ])
+    });
+};
+const pickKeys = (obj, keys)=>{
+    return Object.fromEntries(Object.entries(obj).filter(([key])=>keys.includes(key)));
+};
+
+const importPostcssModules = createCachedImport(()=>import('./index-C7SN2-vF.js').then(function (n) { return n.i; }));
+const importPostcss = createCachedImport(()=>import('postcss'));
+const nextFontPostcss = async (relativePathFromRoot, { css, fallbackFonts, weight, style, adjustFontFallback, variable })=>{
+    // Exports will be exported as is from css-loader instead of a CSS module export
+    // const exports: { name: any; value: any }[] = [];
+    // Generate a hash from the CSS content. Used to generate classnames
+    const fontFamilyHash = loaderUtils.getHashDigest(Buffer.from(css), 'sha1', 'hex', 6);
+    let modules;
+    const result = await runPostCss({
+        postcssPlugins: [
+            (postcssNextFontPlugin.default || postcssNextFontPlugin)({
+                exports: [],
+                fallbackFonts,
+                weight,
+                style,
+                adjustFontFallback,
+                variable
+            }),
+            (await importPostcssModules()).default({
+                generateScopedName: (originalClassName)=>{
+                    // hash from next-font-loader
+                    return `__${originalClassName}_${fontFamilyHash}`;
+                },
+                getJSON (_cssFileName, _modules, _outputFileName) {
+                    modules = _modules;
+                }
+            })
+        ],
+        postcssOptions: {
+            from: relativePathFromRoot
+        },
+        code: css
+    });
+    return {
+        ...result,
+        modules
+    };
+};
+const runPostCss = async ({ postcssPlugins = [], postcssOptions = {}, code })=>{
+    let postcssResult;
+    try {
+        const postcss = await importPostcss();
+        // postcss is an unbundled dep and should be lazy imported
+        postcssResult = await postcss.default(postcssPlugins).process(code, postcssOptions);
+    } catch (e) {
+        if (typeof e === 'object' && e !== null && 'message' in e && 'file' in e && 'line' in e && 'column' in e && typeof e.column === 'number') {
+            throw Object.assign({}, {
+                message: `[postcss] ${e.message}`,
+                code,
+                loc: {
+                    file: e.file,
+                    line: e.line,
+                    column: e.column - 1
+                }
+            });
+        }
+    }
+    return {
+        code: postcssResult.css,
+        map: {
+            mappings: ''
+        }
+    };
+};
+
+const googleLoader = createCachedImport(()=>import('next-font/google/loader').then((mod)=>mod.default));
+const localLoader = createCachedImport(()=>import('next-font/local/loader').then((mod)=>mod.default));
+const nextFontLoaderPlugin = ({ nextFontManifest, fontImports, onFinished })=>{
+    let config = null;
+    const fileToFontNames = new Map();
+    const loaderCache = {
+        google: {
+            css: new Map(),
+            font: new Map()
+        },
+        local: {
+            css: new Map(),
+            font: new Map()
+        }
+    };
+    const fontLoaders = [
+        [
+            'next-font/google/target.css',
+            googleLoader(),
+            loaderCache.google
+        ],
+        [
+            'next-font/local/target.css',
+            localLoader(),
+            loaderCache.local
+        ]
+    ];
+    const targetCssMap = new Map();
+    const removeTargetCss = (id)=>{
+        targetCssMap.delete(id);
+        const { path: relativePathFromRoot } = queryString.parse(getQuerySuffix(id));
+        const absPath = path.join(config.root, relativePathFromRoot);
+        const fontNames = fileToFontNames.get(absPath)?.[id];
+        if (fontNames) {
+            if (nextFontManifest[absPath]) {
+                nextFontManifest[absPath] = nextFontManifest[absPath].filter((font)=>!fontNames.includes(font));
+            }
+            for (const fontName of fontNames){
+                fontFileMap.set(fontNameToUrl(fontName), Object.assign({}, fontFileMap.get(fontNameToUrl(fontName)), {
+                    serve: false
+                }));
+            }
+        }
+    };
+    const fontFileMap = new Map();
+    let lastEnv = null;
+    let calledFinished = false;
+    const resetCalledFinished = ()=>{
+        calledFinished = false;
+    };
+    return [
+        {
+            resetCalledFinished,
+            removeTargetCss
+        },
+        [
+            {
+                name: 'next-font:loader:scan',
+                enforce: 'pre',
+                async configResolved (resolvedConfig) {
+                    config = resolvedConfig;
+                },
+                configureServer (server) {
+                    return ()=>{
+                        server.middlewares.use((req, res, next)=>{
+                            if (!req.originalUrl) return next();
+                            const font = fontFileMap.get(req.originalUrl);
+                            if (font?.serve) {
+                                res.end(font.content);
+                            } else next();
+                        });
+                    };
+                }
+            },
+            {
+                name: 'next-font:loader',
+                load: {
+                    order: 'pre',
+                    async handler (id, opts) {
+                        if (!/\.css(?:$|\?)/.test(id)) return null;
+                        const { data: resolvedId, error } = await tryCatch(importResolve(removeQuerySuffix(id)));
+                        if (error) return null;
+                        const pair = fontLoaders.find((id)=>import.meta.resolve(id[0]) === resolvedId);
+                        if (!pair) return null;
+                        const [, fontLoader, cache] = pair;
+                        const normalizedId = normalizeTargetCssId(id);
+                        const isDev = config?.command === 'serve';
+                        if (// unnecessary to load the same file in dev mode
+                        isDev && targetCssMap.has(normalizedId) && lastEnv === this.environment.name) return;
+                        lastEnv = this.environment.name;
+                        const { path: relativePathFromRoot, import: functionName, arguments: stringifiedArguments, variableName } = queryString.parse(getQuerySuffix(id));
+                        const data = JSON.parse(stringifiedArguments);
+                        const fontNames = [];
+                        const emitFontFile = (content, ext, preload, isUsingSizeAdjust)=>{
+                            const name = loaderUtils.interpolateName(// @ts-expect-error
+                            {}, `static/media/[hash]${isUsingSizeAdjust ? '-s' : ''}${preload ? '.p' : ''}.${ext}`, {
+                                content
+                            });
+                            fontNames.push(name);
+                            const outputPath = fontNameToUrl(name);
+                            if (!isDev) {
+                                this.emitFile({
+                                    type: 'asset',
+                                    fileName: outputPath.slice(1),
+                                    source: content
+                                });
+                            }
+                            fontFileMap.set(outputPath, {
+                                content,
+                                serve: isDev
+                            });
+                            return outputPath;
+                        };
+                        const absPath = path.join(config.root, relativePathFromRoot);
+                        const fontData = await (await fontLoader)({
+                            functionName,
+                            variableName,
+                            data,
+                            emitFontFile,
+                            loaderContext: this,
+                            cache,
+                            isDev,
+                            isServer: opts?.ssr ?? false,
+                            resolve: (src)=>{
+                                return path.join(path.dirname(absPath), src.startsWith('.') ? src : `./${src}`);
+                            }
+                        });
+                        const normalizedAbsPath = normalizePath(absPath);
+                        fileToFontNames.set(normalizedAbsPath, {
+                            ...fileToFontNames.get(normalizedAbsPath),
+                            [normalizedId]: Array.from(new Set((fileToFontNames.get(normalizedAbsPath)?.[normalizedId] || []).concat(fontNames)))
+                        });
+                        const targetCss = await nextFontPostcss(relativePathFromRoot, fontData);
+                        if (fontImports[normalizedAbsPath]) {
+                            for (const fontImport of fontImports[normalizedAbsPath]){
+                                if (fileURLToPath(import.meta.resolve(removeQuerySuffix(fontImport.id))).concat(getQuerySuffix(fontImport.id)) === encodeURIPath(id)) {
+                                    fontImport.css = targetCss.code;
+                                }
+                            }
+                            if (!calledFinished && !Object.values(fontImports).flat().filter((i)=>!i.css).length) {
+                                await onFinished(fileToFontNames).finally(()=>{
+                                    calledFinished = true;
+                                });
+                            }
+                        }
+                        targetCssMap.set(normalizedId, targetCss);
+                    }
+                },
+                transform: {
+                    order: 'post',
+                    async handler (_code, id, opts) {
+                        if (!/\.css(?:$|\?)/.test(id)) return null;
+                        console.log(id);
+                        const normalizedId = normalizeTargetCssId(id);
+                        const targetCss = targetCssMap.get(normalizedId);
+                        if (!targetCss) return null;
+                        const { modules, code: css } = targetCss;
+                        const modulesCode = dataToEsm(modules, {
+                            namedExports: true,
+                            preferConst: true
+                        });
+                        const map = config?.css.devSourcemap ? new MagicString(css).generateMap({
+                            hires: true
+                        }) : undefined;
+                        if (config?.command === 'serve' && !opts?.ssr) {
+                            const code = [
+                                `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path.posix.join(config.base, '/@vite/client'))}`,
+                                `const __vite__id = ${JSON.stringify(id)}`,
+                                `const __vite__css = ${JSON.stringify(css)}`,
+                                `__vite__updateStyle(__vite__id, __vite__css)`,
+                                modulesCode,
+                                `if (import.meta.hot) {
+                  import.meta.hot.accept()
+                  import.meta.hot.prune(() => __vite__removeStyle(__vite__id))
+                }`
+                            ].join('\n');
+                            return {
+                                code,
+                                map
+                            };
+                        }
+                        return {
+                            code: modulesCode,
+                            map,
+                            moduleSideEffects: false
+                        };
+                    }
+                }
+            },
+            {
+                name: 'next-font:build',
+                apply: 'build',
+                renderChunk: {
+                    order: 'post',
+                    async handler (_code, chunk) {
+                        const resolvedModuleIds = (await Promise.all(chunk.moduleIds.map(async (moduleId)=>this.resolve(moduleId).then((resolved)=>resolved?.id)))).filter(Boolean);
+                        if (resolvedModuleIds.length) {
+                            const targetCss = resolvedModuleIds.map((id)=>Object.assign({}, targetCssMap.get(normalizeTargetCssId(id)) ?? {}, {
+                                    id
+                                })).filter((t)=>t != null && 'code' in t && typeof t.code === 'string');
+                            const chunkCSS = targetCss.map((t)=>t.code).join();
+                            function ensureFileExt(name, ext) {
+                                return normalizePath(path.format({
+                                    ...path.parse(name),
+                                    base: undefined,
+                                    ext
+                                }));
+                            }
+                            if (chunkCSS) {
+                                const cssFullAssetName = ensureFileExt(chunk.name, '.css');
+                                // if facadeModuleId doesn't exist or doesn't have a CSS extension,
+                                // that means a JS entry file imports a CSS file.
+                                // in this case, only use the filename for the CSS chunk name like JS chunks.
+                                const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path.basename(cssFullAssetName) : cssFullAssetName;
+                                // emit corresponding css file
+                                const referenceId = this.emitFile({
+                                    type: 'asset',
+                                    name: cssAssetName,
+                                    source: chunkCSS
+                                });
+                                chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
+                            }
+                        }
+                        return null;
+                    }
+                }
+            }
+        ]
+    ];
+};
+
+const nextFontManifestPlugin = ({ nextFontManifest })=>{
+    let config = null;
+    return [
+        {
+            name: 'next-font:manifest',
+            configResolved (resolvedConfig) {
+                config = resolvedConfig;
+            },
+            transform: {
+                order: 'post',
+                async handler (_code, id) {
+                    const { data: resolvedId, error } = await tryCatch(importResolve(id));
+                    if (error != null || resolvedId == null) return;
+                    if (resolvedId === import.meta.resolve('next-font/manifest')) {
+                        return [
+                            `function encodeURIPath(file) {
+                return file
+                  .split('/')
+                  .map((p) => encodeURIComponent(p))
+                  .join('/')
+              }`,
+                            `const injectedFontPreloadTags = new Set();`,
+                            `const __NEXT_FONT_MANIFEST__ = ${JSON.stringify(nextFontManifest, null, 2)};`,
+                            dataToEsm({
+                                manifest: undefined,
+                                getPreloadableFonts: undefined,
+                                getFontMetadata: undefined
+                            }, {
+                                preferConst: true,
+                                namedExports: true
+                            }).replace('export const manifest = undefined;', `export const manifest = Object.freeze(__NEXT_FONT_MANIFEST__);`).replace('export const getPreloadableFonts = undefined;', `export const getPreloadableFonts = (filePath) => {
+    if (!manifest || !filePath) return null;
+    const fontFiles = new Set();
+    let foundFontUsage = false;
+    const preloadedFontFiles = manifest[filePath];
+    if (preloadedFontFiles) {
+      foundFontUsage = true;
+      for (let fontFile of preloadedFontFiles) {
+        fontFile = \`/${config.build.assetsDir}/_next/\${fontFile}\`;
+        fontFiles.add(fontFile);
+        injectedFontPreloadTags.add(fontFile);
+      }
+    }
+    if (fontFiles.size) {
+     return [...fontFiles].sort();
+    } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {
+     return [];
+    } else {
+     return null;
+    }
+  }`).replace('export const getFontMetadata = undefined;', `export const getFontMetadata = (filePath) => {
+    const metadata = {
+      preload: [],
+      preconnect: []
+    };
+    const preloadedFontFiles = filePath
+        ? getPreloadableFonts(filePath)
+        : null;
+    if (preloadedFontFiles) {
+        if (preloadedFontFiles.length) {
+          for (let i = 0; i < preloadedFontFiles.length; i++) {
+            const fontFilename = preloadedFontFiles[i];
+            const ext = /.(woff|woff2|eot|ttf|otf)$/.exec(fontFilename)[1];
+            const type = \`font/\${ext}\`;
+            const href = encodeURIPath(fontFilename);
+
+            metadata.preload.push({
+              href,
+              type,
+              crossOrigin: undefined,
+              nonce: undefined
+            });
+          }
+        } else {
+          try {
+            let url = new URL('/' + '${config.build.assetsDir}');
+            metadata.preconnect.push({
+              href: url.origin,
+              crossOrigin: undefined,
+              nonce: undefined
+            });
+          } catch (error) {
+            // assetPrefix must not be a fully qualified domain name. We assume
+            // we should preconnect to same origin instead
+            metadata.preconnect.push({
+              href: '/',
+              crossOrigin: '',
+              nonce: null
+            });
+          }
+        }
+      }
+
+      return metadata;
+  }`),
+                            `if (import.meta.hot) import.meta.hot.accept(${JSON.stringify(id)}, () => {
+                manifest = __NEXT_FONT_MANIFEST__;
+              })`
+                        ].join('\n');
+                    }
+                }
+            }
+        }
+    ];
+};
+
+/**
+ * @typedef { import('estree').Node} Node
+ * @typedef {{
+ *   skip: () => void;
+ *   remove: () => void;
+ *   replace: (node: Node) => void;
+ * }} WalkerContext
+ */ class WalkerBase {
+    constructor(){
+        /** @type {boolean} */ this.should_skip = false;
+        /** @type {boolean} */ this.should_remove = false;
+        /** @type {Node | null} */ this.replacement = null;
+        /** @type {WalkerContext} */ this.context = {
+            skip: ()=>this.should_skip = true,
+            remove: ()=>this.should_remove = true,
+            replace: (node)=>this.replacement = node
+        };
+    }
+    /**
+	 * @template {Node} Parent
+	 * @param {Parent | null | undefined} parent
+	 * @param {keyof Parent | null | undefined} prop
+	 * @param {number | null | undefined} index
+	 * @param {Node} node
+	 */ replace(parent, prop, index, node) {
+        if (parent && prop) {
+            if (index != null) {
+                /** @type {Array<Node>} */ parent[prop][index] = node;
+            } else {
+                /** @type {Node} */ parent[prop] = node;
+            }
+        }
+    }
+    /**
+	 * @template {Node} Parent
+	 * @param {Parent | null | undefined} parent
+	 * @param {keyof Parent | null | undefined} prop
+	 * @param {number | null | undefined} index
+	 */ remove(parent, prop, index) {
+        if (parent && prop) {
+            if (index !== null && index !== undefined) {
+                /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+            } else {
+                delete parent[prop];
+            }
+        }
+    }
+}
+
+/**
+ * @typedef { import('estree').Node} Node
+ * @typedef { import('./walker.js').WalkerContext} WalkerContext
+ * @typedef {(
+ *    this: WalkerContext,
+ *    node: Node,
+ *    parent: Node | null,
+ *    key: string | number | symbol | null | undefined,
+ *    index: number | null | undefined
+ * ) => void} SyncHandler
+ */ class SyncWalker extends WalkerBase {
+    /**
+	 *
+	 * @param {SyncHandler} [enter]
+	 * @param {SyncHandler} [leave]
+	 */ constructor(enter, leave){
+        super();
+        /** @type {boolean} */ this.should_skip = false;
+        /** @type {boolean} */ this.should_remove = false;
+        /** @type {Node | null} */ this.replacement = null;
+        /** @type {WalkerContext} */ this.context = {
+            skip: ()=>this.should_skip = true,
+            remove: ()=>this.should_remove = true,
+            replace: (node)=>this.replacement = node
+        };
+        /** @type {SyncHandler | undefined} */ this.enter = enter;
+        /** @type {SyncHandler | undefined} */ this.leave = leave;
+    }
+    /**
+	 * @template {Node} Parent
+	 * @param {Node} node
+	 * @param {Parent | null} parent
+	 * @param {keyof Parent} [prop]
+	 * @param {number | null} [index]
+	 * @returns {Node | null}
+	 */ visit(node, parent, prop, index) {
+        if (node) {
+            if (this.enter) {
+                const _should_skip = this.should_skip;
+                const _should_remove = this.should_remove;
+                const _replacement = this.replacement;
+                this.should_skip = false;
+                this.should_remove = false;
+                this.replacement = null;
+                this.enter.call(this.context, node, parent, prop, index);
+                if (this.replacement) {
+                    node = this.replacement;
+                    this.replace(parent, prop, index, node);
+                }
+                if (this.should_remove) {
+                    this.remove(parent, prop, index);
+                }
+                const skipped = this.should_skip;
+                const removed = this.should_remove;
+                this.should_skip = _should_skip;
+                this.should_remove = _should_remove;
+                this.replacement = _replacement;
+                if (skipped) return node;
+                if (removed) return null;
+            }
+            /** @type {keyof Node} */ let key;
+            for(key in node){
+                /** @type {unknown} */ const value = node[key];
+                if (value && typeof value === 'object') {
+                    if (Array.isArray(value)) {
+                        const nodes = /** @type {Array<unknown>} */ value;
+                        for(let i = 0; i < nodes.length; i += 1){
+                            const item = nodes[i];
+                            if (isNode(item)) {
+                                if (!this.visit(item, node, key, i)) {
+                                    // removed
+                                    i--;
+                                }
+                            }
+                        }
+                    } else if (isNode(value)) {
+                        this.visit(value, node, key, null);
+                    }
+                }
+            }
+            if (this.leave) {
+                const _replacement = this.replacement;
+                const _should_remove = this.should_remove;
+                this.replacement = null;
+                this.should_remove = false;
+                this.leave.call(this.context, node, parent, prop, index);
+                if (this.replacement) {
+                    node = this.replacement;
+                    this.replace(parent, prop, index, node);
+                }
+                if (this.should_remove) {
+                    this.remove(parent, prop, index);
+                }
+                const removed = this.should_remove;
+                this.replacement = _replacement;
+                this.should_remove = _should_remove;
+                if (removed) return null;
+            }
+        }
+        return node;
+    }
+}
+/**
+ * Ducktype a node.
+ *
+ * @param {unknown} value
+ * @returns {value is Node}
+ */ function isNode(value) {
+    return value !== null && typeof value === 'object' && 'type' in value && typeof value.type === 'string';
+}
+
+/**
+ * @typedef {import('estree').Node} Node
+ * @typedef {import('./sync.js').SyncHandler} SyncHandler
+ * @typedef {import('./async.js').AsyncHandler} AsyncHandler
+ */ /**
+ * @param {Node} ast
+ * @param {{
+ *   enter?: SyncHandler
+ *   leave?: SyncHandler
+ * }} walker
+ * @returns {Node | null}
+ */ function walk(ast, { enter, leave }) {
+    const instance = new SyncWalker(enter, leave);
+    return instance.visit(ast, null);
+}
+
+class FindFunctionsOutsideModuleScope {
+    constructor({ state }){
+        this.state = state;
+    }
+    visit(ast) {
+        walk(ast, {
+            enter: (node)=>{
+                if (node.type === 'Identifier') {
+                    this.visitIdent(node);
+                }
+            }
+        });
+    }
+    visitIdent(ident) {
+        if (ident.name in this.state.fontFunctions && !this.state.fontFunctionsInAllowedScope.includes(ident.start)) {
+            throw new Error('Font loaders must be called and assigned to a const in the module scope');
+        }
+    }
+}
+
+class FontFunctionsCollector {
+    constructor({ state, fontLoaders, remapImports }){
+        this.state = state;
+        this.fontLoaders = fontLoaders;
+        this.remapImports = remapImports;
+    }
+    visit(ast) {
+        walk(ast, {
+            enter: (node)=>{
+                if (node.type === 'ImportDeclaration') {
+                    this.visitImportDecl(node);
+                }
+            }
+        });
+    }
+    visitImportDecl(importDecl) {
+        if (typeof importDecl.source.value !== 'string') return;
+        let resolvedId = null;
+        try {
+            resolvedId = import.meta.resolve(removeQuerySuffix(this.remapImports[importDecl.source.value] || importDecl.source.value));
+        } catch  {}
+        if (resolvedId != null && this.fontLoaders.map((fontLoader)=>import.meta.resolve(fontLoader)).includes(resolvedId)) {
+            this.state.removeableModuleItems.push(importDecl.start);
+            for (const specifier of importDecl.specifiers){
+                const { local, functionName } = (()=>{
+                    switch(specifier.type){
+                        case 'ImportSpecifier':
+                            {
+                                const { local, imported } = specifier;
+                                const functionName = imported.type === 'Identifier' ? imported.name : local.name;
+                                return {
+                                    local,
+                                    functionName
+                                };
+                            }
+                        case 'ImportDefaultSpecifier':
+                            {
+                                const { local } = specifier;
+                                return {
+                                    local
+                                };
+                            }
+                        case 'ImportNamespaceSpecifier':
+                            {
+                                throw new Error("Font loaders can't have namespace imports");
+                            }
+                    }
+                })();
+                this.state.fontFunctionsInAllowedScope.push(local.start);
+                this.state.fontFunctions[local.name] = {
+                    functionName,
+                    loader: importDecl.source.value
+                };
+            }
+        }
+    }
+}
+
+const o = new WeakMap;
+let u = 0;
+function stableHash(t) {
+    const i = typeof t, s = t && t.constructor, c = s === Date;
+    if (Object(t) === t && !c && s != RegExp) {
+        let e = o.get(t);
+        if (e) return e;
+        e = ++u + "~", o.set(t, e);
+        let n;
+        if (s === Array) {
+            for(e = "@", n = 0; n < t.length; n++)e += stableHash(t[n]) + ",";
+            o.set(t, e);
+        } else if (s === Object) {
+            e = "#";
+            const f = Object.keys(t).sort();
+            for(; (n = f.pop()) !== void 0;)t[n] !== void 0 && (e += n + ":" + stableHash(t[n]) + ",");
+            o.set(t, e);
+        }
+        return e;
+    }
+    return c ? t.toJSON() : i === "symbol" ? t.toString() : i === "string" ? JSON.stringify(t) : "" + t;
+}
+
+const DUMMY_SP = {
+    start: 0,
+    end: 0
+};
+
+const exprToJson = (expr)=>{
+    switch(expr.type){
+        case 'Literal':
+            return expr.value;
+        case 'ObjectExpression':
+            return objectLitToJson(expr);
+        case 'ArrayExpression':
+            {
+                const elements = expr.elements.map((e)=>{
+                    if (e) {
+                        if (e.type === 'SpreadElement') throw new Error('Unexpected spread');
+                        return exprToJson(e);
+                    } else {
+                        throw new Error('Unexpected empty value in array');
+                    }
+                });
+                return elements;
+            }
+        default:
+            throw new Error('Font loader values must be explicitly written literals.');
+    }
+};
+const objectLitToJson = (objectLit)=>{
+    const values = {};
+    for (const prop of objectLit.properties){
+        if (prop.type === 'SpreadElement') throw new Error('Unexpected spread');
+        if (prop.kind !== 'init') throw new Error('Unexpected key');
+        if (prop.key.type !== 'Identifier') throw new Error('Unexpected object key type');
+        values[prop.key.name] = exprToJson(prop.value);
+    }
+    return values;
+};
+
+class FontImportsGenerator {
+    constructor({ state, id, remapImports }){
+        this.state = state;
+        this.id = id;
+        this.remapImports = remapImports;
+    }
+    visit(ast) {
+        walk(ast, {
+            enter: (node)=>{
+                if (node.type === 'VariableDeclaration') {
+                    this.checkVarDecl(node);
+                }
+                if (node.type === 'VariableDeclaration') {
+                    if (this.checkVarDecl(node) != null) this.state.removeableModuleItems.push(node.start);
+                }
+                if (node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration') {
+                    const exportDecl = node;
+                    if (exportDecl.declaration?.type === 'VariableDeclaration') {
+                        const varDecl = exportDecl.declaration;
+                        const ident = this.checkVarDecl(varDecl);
+                        if (ident) {
+                            this.state.removeableModuleItems.push(exportDecl.start);
+                            this.state.fontExports.push({
+                                type: 'ExportNamedDeclaration',
+                                specifiers: [
+                                    {
+                                        type: 'ExportSpecifier',
+                                        local: ident,
+                                        exported: {
+                                            name: ident.name,
+                                            type: 'Identifier',
+                                            ...DUMMY_SP
+                                        },
+                                        ...DUMMY_SP
+                                    }
+                                ],
+                                attributes: [],
+                                ...DUMMY_SP
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    }
+    checkVarDecl(varDecl) {
+        const decl = varDecl.declarations[0];
+        const ident = decl?.id;
+        const expr = decl?.init;
+        if (expr?.type === 'CallExpression') {
+            const callExpr = expr;
+            const importDecl = this.checkCallExpr(callExpr, ident);
+            if (importDecl) {
+                if (varDecl.kind !== 'const') throw new Error('Font loader calls must be assigned to a const');
+                if (!ident) throw new Error('Font loader calls must be assigned to an identifier');
+                importDecl.specifiers = [
+                    {
+                        type: 'ImportDefaultSpecifier',
+                        local: ident,
+                        ...DUMMY_SP
+                    }
+                ];
+                if (!this.state.fontImports.map(stableHash).includes(stableHash(importDecl))) {
+                    // @ts-expect-error
+                    this.state.fontImports.push(importDecl);
+                }
+                return ident;
+            }
+        }
+    }
+    checkCallExpr(callExpr, variableName) {
+        if (callExpr.callee.type === 'Identifier') {
+            const ident = callExpr.callee;
+            const fontFunction = this.state.fontFunctions[ident.name];
+            if (fontFunction) {
+                this.state.fontFunctionsInAllowedScope.push(ident.start);
+                const json = callExpr.arguments.map((expr_or_spread)=>{
+                    if (expr_or_spread.type === 'SpreadElement') throw new Error("Font loaders don't accept spreads");
+                    return exprToJson(expr_or_spread);
+                });
+                const functionName = fontFunction.functionName ?? '';
+                const queryJson = {
+                    path: this.id,
+                    import: functionName,
+                    arguments: json,
+                    variableName: variableName?.name ?? ''
+                };
+                return {
+                    type: 'ImportDeclaration',
+                    source: {
+                        type: 'Literal',
+                        value: queryString.stringifyUrl({
+                            url: path.posix.join(this.remapImports[fontFunction.loader] || fontFunction.loader, 'target.css'),
+                            query: Object.assign({}, queryJson, {
+                                arguments: JSON.stringify(queryJson.arguments)
+                            })
+                        }),
+                        ...DUMMY_SP
+                    },
+                    specifiers: [],
+                    attributes: [],
+                    ...DUMMY_SP
+                };
+            }
+        }
+    }
+}
+
+const visit = ({ ast, fontLoaders, id, remapImports })=>{
+    const state = new Proxy({
+        removeableModuleItems: [],
+        fontFunctionsInAllowedScope: [],
+        fontFunctions: {},
+        fontImports: [],
+        fontExports: []
+    }, {
+        set (target, prop, value) {
+            target[prop] = value;
+            return true;
+        },
+        get (target, prop) {
+            return target[prop];
+        }
+    });
+    const functionsCollector = new FontFunctionsCollector({
+        state,
+        fontLoaders,
+        remapImports
+    });
+    functionsCollector.visit(ast);
+    if (state.removeableModuleItems.length > 0) {
+        const importGenerator = new FontImportsGenerator({
+            state,
+            id,
+            remapImports
+        });
+        importGenerator.visit(ast);
+        const wrongScope = new FindFunctionsOutsideModuleScope({
+            state
+        });
+        wrongScope.visit(ast);
+        const isRemovable = (node)=>{
+            return state.removeableModuleItems.includes(node.start);
+        };
+        // @ts-expect-error
+        const firstRemovableIndex = ast.body.findIndex(isRemovable);
+        // Remove marked module items
+        walk(ast, {
+            enter (node) {
+                // @ts-expect-error
+                if (isRemovable(node)) this.remove();
+            }
+        });
+        // Add font imports and exports
+        ast.body.splice(firstRemovableIndex, 0, ...state.fontImports);
+        ast.body.push(...state.fontExports);
+        return {
+            changed: true,
+            state
+        };
+    }
+    return {
+        changed: false,
+        state
+    };
+};
+
+const importEscodegen = createCachedImport(()=>// @ts-expect-error
+    import('./escodegen-CE_3K55m.js').then(function (n) { return n.e; }));
+const nextFontTransformerPlugin = ({ fontImports, onFontImportsChanged })=>{
+    let config = null;
+    const rewriteNextFontImport = {
+        '@next/font/google': 'next-font/google',
+        '@next/font/local': 'next-font/local',
+        'next/font/google': 'next-font/google',
+        'next/font/local': 'next-font/local'
+    };
+    const importedLoaders = [
+        'next-font/google',
+        'next-font/local'
+    ];
+    return [
+        {
+            name: 'next-font:transform',
+            async configResolved (resolvedConfig) {
+                config = resolvedConfig;
+            },
+            async transform (code, id) {
+                if (!/\.(?:j|t)sx?$|\.mjs$/.test(id)) return null;
+                const parse = async ()=>this.parse(code, {
+                        jsx: true
+                    });
+                const { data: ast, error } = await tryCatch(parse());
+                if (error) {
+                    this.error(error);
+                }
+                if (!ast) return;
+                const { changed, state } = visit({
+                    ast,
+                    fontLoaders: importedLoaders,
+                    id: path.relative(config.root, id),
+                    remapImports: rewriteNextFontImport
+                });
+                if (!changed) return;
+                const nextFontImports = state.fontImports.map((i)=>i.source.value);
+                const previousFontImports = fontImports[id];
+                if (previousFontImports) {
+                    const importsChanged = nextFontImports.some((i)=>!previousFontImports.some((p)=>p.id === i));
+                    if (importsChanged) {
+                        onFontImportsChanged(id, nextFontImports, previousFontImports.map((i)=>i.id));
+                    }
+                }
+                fontImports[id] = nextFontImports.map((i)=>({
+                        id: i
+                    }));
+                const escodegen = await importEscodegen();
+                const s = new MagicString('');
+                for (const node of ast.body){
+                    s.append(escodegen.generate(node));
+                    s.append('\n');
+                }
+                return {
+                    code: s.toString()
+                };
+            }
+        }
+    ];
+};
+
+const nextFont = ()=>{
+    const servers = [];
+    const fontImports = new Proxy({}, {
+        get (t, p, r) {
+            return Reflect.get(t, p, r);
+        },
+        set (t, p, v, r) {
+            return Reflect.set(t, p, v, r);
+        }
+    });
+    const nextFontManifest = {
+        isUsingSizeAdjust: false
+    };
+    const reloadManifest = ()=>{
+        for (const server of servers){
+            const manifestId = fileURLToPath(import.meta.resolve('next-font/manifest'));
+            const manifestMod = server.moduleGraph.getModuleById(manifestId);
+            if (manifestMod) {
+                server.reloadModule(manifestMod);
+                server.moduleGraph.invalidateModule(manifestMod);
+                server.moduleGraph.onFileChange(manifestId);
+                server.ws.send({
+                    type: 'full-reload',
+                    path: manifestId
+                });
+            }
+        }
+    };
+    const onFinished = async (fileToFontNames)=>{
+        for (const [id, targetCss] of fileToFontNames){
+            for (const fontFiles of Object.values(targetCss)){
+                // Look if size-adjust fallback font is being used
+                if (!nextFontManifest.isUsingSizeAdjust) {
+                    nextFontManifest.isUsingSizeAdjust = getPageIsUsingSizeAdjust(fontFiles);
+                }
+                const preloadedFontFiles = getPreloadedFontFiles(fontFiles);
+                // Add an entry of the module's font files in the manifest.
+                // We'll add an entry even if no files should preload.
+                // When an entry is present but empty, instead of preloading the font files, a preconnect tag is added.
+                if (fontFiles.length > 0) {
+                    nextFontManifest[id] ||= [];
+                    nextFontManifest[id] = Array.from(new Set(nextFontManifest[id].concat(preloadedFontFiles)));
+                }
+            }
+        }
+        reloadManifest();
+    };
+    const [{ resetCalledFinished, removeTargetCss }, loaderPlugin] = nextFontLoaderPlugin({
+        nextFontManifest,
+        fontImports,
+        onFinished
+    });
+    return [
+        {
+            name: 'next-font:scan',
+            configureServer (server) {
+                servers.push(server);
+            }
+        },
+        nextFontTransformerPlugin({
+            fontImports,
+            onFontImportsChanged: async (_id, newValue, previousValue)=>{
+                resetCalledFinished();
+                const removed = previousValue.filter((p)=>!newValue.includes(p));
+                for (const server of servers){
+                    for (const id of removed){
+                        const resolvedId = fileURLToPath(import.meta.resolve(removeQuerySuffix(id))) + getQuerySuffix(id);
+                        removeTargetCss(normalizeTargetCssId(resolvedId));
+                        const module = server.moduleGraph.getModuleById(resolvedId);
+                        if (module) {
+                            server.moduleGraph.onFileDelete(resolvedId);
+                            server.ws.send({
+                                type: 'prune',
+                                paths: [
+                                    resolvedId
+                                ]
+                            });
+                            server.ws.send({
+                                type: 'update',
+                                updates: [
+                                    {
+                                        type: 'css-update',
+                                        path: resolvedId,
+                                        acceptedPath: resolvedId,
+                                        timestamp: Date.now()
+                                    },
+                                    {
+                                        type: 'css-update',
+                                        path: id,
+                                        acceptedPath: id,
+                                        timestamp: Date.now()
+                                    }
+                                ]
+                            });
+                            // server.moduleGraph.invalidateModule(module)
+                            server.reloadModule(module);
+                            server.ws.send({
+                                type: 'full-reload',
+                                path: resolvedId
+                            });
+                        }
+                    }
+                    reloadManifest();
+                }
+            }
+        }),
+        loaderPlugin,
+        nextFontManifestPlugin({
+            nextFontManifest
+        })
+    ];
+};
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g, nextFont as n, requireInterpolateName as r };
+//# sourceMappingURL=index-y2m5QvKY.js.map