}

		// This helps for lowering for-await loops
		export var __forAwait = (obj, it, method) =>
			(it = obj[__knownSymbol('asyncIterator')])
				? it.call(obj)
				: (obj = obj[__knownSymbol('iterator')](),
					it = {},
					method = (key, fn) =>
						(fn = obj[key]) && (it[key] = arg =>
							new Promise((yes, no, done) => (
								arg = fn.call(obj, arg),
								done = arg.done,
								Promise.resolve(arg.value)
									.then(value => yes({ value, done }), no)
							))),
					method('next'),
					method('return'),
					it)

		// This is for the "binary" loader (custom code is ~2x faster than "atob")
		export var __toBinaryNode = base64 => new Uint8Array(Buffer.from(base64, 'base64'))
		export var __toBinary = /* @__PURE__ */ (() => {
			var table = new Uint8Array(128)
			for (var i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i
			return base64 => {
				var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == '=') - (base64[n - 2] == '=')) * 3 / 4 | 0)
				for (var i = 0, j = 0; i < n;) {
					var c0 = table[base64.charCodeAt(i++)], c1 = table[base64.charCodeAt(i++)]
					var c2 = table[base64.charCodeAt(i++)], c3 = table[base64.charCodeAt(i++)]
					bytes[j++] = (c0 << 2) | (c1 >> 4)
					bytes[j++] = (c1 << 4) | (c2 >> 2)
					bytes[j++] = (c2 << 6) | c3
				}
				return bytes
			}
		})()

		// These are for the "using" statement in TypeScript 5.2+
		export var __using = (stack, value, async) => {
			if (value != null) {
				if (typeof value !== 'object' && typeof value !== 'function') __typeError('Object expected')
				var dispose
				if (async) dispose = value[__knownSymbol('asyncDispose')]
				if (dispose === void 0) dispose = value[__knownSymbol('dispose')]
				if (typeof dispose !== 'function') __typeError('Object not disposable')
				stack.push([async, dispose, value])
			} else if (async) {
				stack.push([async])
			}
			return value
		}
		export var __callDispose = (stack, error, hasError) => {
			var E = typeof SuppressedError === 'function' ? SuppressedError :
				function (e, s, m, _) { return _ = Error(m), _.name = 'SuppressedError', _.error = e, _.suppressed = s, _ }
			var fail = e => error = hasError ? new E(e, error, 'An error was suppressed during disposal') : (hasError = true, e)
			var next = (it) => {
				while (it = stack.pop()) {
					try {
						var result = it[1] && it[1].call(it[2])
						if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()))
					} catch (e) {
						fail(e)
					}
				}
				if (hasError) throw error
			}
			return next()
		}