Greasy Fork is available in English.

Flow Youtube Chat

Youtubeのチャットをニコニコ風に画面上へ流す(再アップ) Make youtube chats move in danmaku-style.

// ==UserScript==
// @name Flow Youtube Chat
// @description Youtubeのチャットをニコニコ風に画面上へ流す(再アップ) Make youtube chats move in danmaku-style.
// @version 1.19.2
// @match https://www.youtube.com/*
// @grant GM.setValue
// @grant GM.getValue
// @grant GM.deleteValue
// @grant GM.listValues
// @grant GM.setClipboard
// @license AGPL-3.0-or-later
// @namespace FlowYoutubeChatScript
// @noframes
// @require https://unpkg.com/rxjs@7.8.1/dist/bundles/rxjs.umd.min.js#sha384-Opyi337NBU4M11Xx1aRUN4dZejlRWsq277uHWHyysNm4frJzmqu7KvgkHu4YWTqk
// @require https://cdn.jsdelivr.net/npm/deep-diff@1.0.2/dist/deep-diff.min.js#sha384-0Ywk0zro7cwc1qs9cJjyGhLbEzWPL9Qw4toVNrYtqHTL7kboLNyhePWOiLBb0lUj
// @require https://cdn.jsdelivr.net/npm/astring@1.8.6/dist/astring.min.js#sha384-/CFO1wx9JFmRDs/KY6V6kvOw79jr7O9zoMW3bKOSQtpK1+QLsT0I1j6fav8u8vvM
// @require https://cdn.jsdelivr.net/npm/jsep@1.3.9/dist/iife/jsep.iife.min.js#sha384-CFM0Dwr/nycUHzB5IWL+HEB2vghQhbUc4NJqz3UCdk+Hu7WpOuFktcvVexJbc4Od
// @require https://cdn.jsdelivr.net/npm/hash-it@6.0.0/dist/min/index.js#sha384-kqUFMXizyaodUGfm0UszFxndXukhSB/yEpOt+q9w/RgjyOK0wz9gXoEYb2FW1/ex
// @require https://cdn.jsdelivr.net/npm/micro-memoize@4.1.2/dist/micro-memoize.min.js#sha384-W1hqD6GTNQ97ZqDR18GhfU1G9qcDLs4sL7BPYND2ncvGNNiLUmUp37Ph+hzm+OPt
// @require https://cdn.jsdelivr.net/npm/lz-string@1.5.0/libs/lz-string.min.js#sha384-0d+Gr7vM4Drod8E3hXKgciWJSWbjD/opKLLygI9ktiWbuvlDwQLzU46wJ9s5gsp7
// @run-at document-end
// ==/UserScript==

/*! For license information please see index.js.LICENSE.txt */
/* jshint esversion: 6 */

;(() => {
	var __webpack_modules__ = {
			371: module => {
				"use strict"
				module.exports = function equal(a, b) {
					if (a === b) return !0
					if (a && b && "object" == typeof a && "object" == typeof b) {
						if (a.constructor !== b.constructor) return !1
						var length, i, keys
						if (Array.isArray(a)) {
							if ((length = a.length) != b.length) return !1
							for (i = length; 0 != i--; ) if (!equal(a[i], b[i])) return !1
							return !0
						}
						if (a.constructor === RegExp)
							return a.source === b.source && a.flags === b.flags
						if (a.valueOf !== Object.prototype.valueOf)
							return a.valueOf() === b.valueOf()
						if (a.toString !== Object.prototype.toString)
							return a.toString() === b.toString()
						if (
							(length = (keys = Object.keys(a)).length) !==
							Object.keys(b).length
						)
							return !1
						for (i = length; 0 != i--; )
							if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return !1
						for (i = length; 0 != i--; ) {
							var key = keys[i]
							if (!equal(a[key], b[key])) return !1
						}
						return !0
					}
					return a != a && b != b
				}
			},
			742: module => {
				module.exports = (function (e) {
					var r = {}
					function t(n) {
						if (r[n]) return r[n].exports
						var a = (r[n] = { i: n, l: !1, exports: {} })
						return e[n].call(a.exports, a, a.exports, t), (a.l = !0), a.exports
					}
					return (
						(t.m = e),
						(t.c = r),
						(t.d = function (e, r, n) {
							t.o(e, r) ||
								Object.defineProperty(e, r, { enumerable: !0, get: n })
						}),
						(t.r = function (e) {
							"undefined" != typeof Symbol &&
								Symbol.toStringTag &&
								Object.defineProperty(e, Symbol.toStringTag, {
									value: "Module",
								}),
								Object.defineProperty(e, "__esModule", { value: !0 })
						}),
						(t.t = function (e, r) {
							if ((1 & r && (e = t(e)), 8 & r)) return e
							if (4 & r && "object" == typeof e && e && e.__esModule) return e
							var n = Object.create(null)
							if (
								(t.r(n),
								Object.defineProperty(n, "default", {
									enumerable: !0,
									value: e,
								}),
								2 & r && "string" != typeof e)
							)
								for (var a in e)
									t.d(
										n,
										a,
										function (r) {
											return e[r]
										}.bind(null, a),
									)
							return n
						}),
						(t.n = function (e) {
							var r =
								e && e.__esModule
									? function () {
											return e.default
										}
									: function () {
											return e
										}
							return t.d(r, "a", r), r
						}),
						(t.o = function (e, r) {
							return Object.prototype.hasOwnProperty.call(e, r)
						}),
						(t.p = ""),
						t((t.s = 0))
					)
				})([
					function (e, r, t) {
						"use strict"
						t.r(r),
							t.d(r, "validateHTMLColorName", function () {
								return l
							}),
							t.d(r, "validateHTMLColorSpecialName", function () {
								return i
							}),
							t.d(r, "validateHTMLColorHex", function () {
								return u
							}),
							t.d(r, "validateHTMLColorRgb", function () {
								return g
							}),
							t.d(r, "validateHTMLColorHsl", function () {
								return y
							}),
							t.d(r, "validateHTMLColorHwb", function () {
								return L
							}),
							t.d(r, "validateHTMLColorLab", function () {
								return S
							}),
							t.d(r, "validateHTMLColorLch", function () {
								return m
							}),
							t.d(r, "validateHTMLColor", function () {
								return G
							})
						const n = e => e && "string" == typeof e,
							a = [
								"AliceBlue",
								"AntiqueWhite",
								"Aqua",
								"Aquamarine",
								"Azure",
								"Beige",
								"Bisque",
								"Black",
								"BlanchedAlmond",
								"Blue",
								"BlueViolet",
								"Brown",
								"BurlyWood",
								"CadetBlue",
								"Chartreuse",
								"Chocolate",
								"Coral",
								"CornflowerBlue",
								"Cornsilk",
								"Crimson",
								"Cyan",
								"DarkBlue",
								"DarkCyan",
								"DarkGoldenrod",
								"DarkGray",
								"DarkGrey",
								"DarkGreen",
								"DarkKhaki",
								"DarkMagenta",
								"DarkOliveGreen",
								"DarkOrange",
								"DarkOrchid",
								"DarkRed",
								"DarkSalmon",
								"DarkSeaGreen",
								"DarkSlateBlue",
								"DarkSlateGray",
								"DarkSlateGrey",
								"DarkTurquoise",
								"DarkViolet",
								"DeepPink",
								"DeepSkyBlue",
								"DimGray",
								"DimGrey",
								"DodgerBlue",
								"FireBrick",
								"FloralWhite",
								"ForestGreen",
								"Fuchsia",
								"Gainsboro",
								"GhostWhite",
								"Gold",
								"Goldenrod",
								"Gray",
								"Grey",
								"Green",
								"GreenYellow",
								"HoneyDew",
								"HotPink",
								"IndianRed",
								"Indigo",
								"Ivory",
								"Khaki",
								"Lavender",
								"LavenderBlush",
								"LawnGreen",
								"LemonChiffon",
								"LightBlue",
								"LightCoral",
								"LightCyan",
								"LightGoldenrodYellow",
								"LightGray",
								"LightGrey",
								"LightGreen",
								"LightPink",
								"LightSalmon",
								"LightSalmon",
								"LightSeaGreen",
								"LightSkyBlue",
								"LightSlateGray",
								"LightSlateGrey",
								"LightSteelBlue",
								"LightYellow",
								"Lime",
								"LimeGreen",
								"Linen",
								"Magenta",
								"Maroon",
								"MediumAquamarine",
								"MediumBlue",
								"MediumOrchid",
								"MediumPurple",
								"MediumSeaGreen",
								"MediumSlateBlue",
								"MediumSlateBlue",
								"MediumSpringGreen",
								"MediumTurquoise",
								"MediumVioletRed",
								"MidnightBlue",
								"MintCream",
								"MistyRose",
								"Moccasin",
								"NavajoWhite",
								"Navy",
								"OldLace",
								"Olive",
								"OliveDrab",
								"Orange",
								"OrangeRed",
								"Orchid",
								"PaleGoldenrod",
								"PaleGreen",
								"PaleTurquoise",
								"PaleVioletRed",
								"PapayaWhip",
								"PeachPuff",
								"Peru",
								"Pink",
								"Plum",
								"PowderBlue",
								"Purple",
								"RebeccaPurple",
								"Red",
								"RosyBrown",
								"RoyalBlue",
								"SaddleBrown",
								"Salmon",
								"SandyBrown",
								"SeaGreen",
								"SeaShell",
								"Sienna",
								"Silver",
								"SkyBlue",
								"SlateBlue",
								"SlateGray",
								"SlateGrey",
								"Snow",
								"SpringGreen",
								"SteelBlue",
								"Tan",
								"Teal",
								"Thistle",
								"Tomato",
								"Turquoise",
								"Violet",
								"Wheat",
								"White",
								"WhiteSmoke",
								"Yellow",
								"YellowGreen",
							],
							o = ["currentColor", "inherit", "transparent"],
							l = e => {
								let r = !1
								return (
									n(e) &&
										a.map(
											t => (
												e.toLowerCase() === t.toLowerCase() && (r = !0), null
											),
										),
									r
								)
							},
							i = e => {
								let r = !1
								return (
									n(e) &&
										o.map(
											t => (
												e.toLowerCase() === t.toLowerCase() && (r = !0), null
											),
										),
									r
								)
							},
							u = e =>
								!!n(e) &&
								e &&
								/^#([\da-f]{3}){1,2}$|^#([\da-f]{4}){1,2}$/i.test(e),
							d = "(([\\d]{0,5})((\\.([\\d]{1,5}))?))",
							s = `(${d}%)`,
							c = "(([0-9]|[1-9][0-9]|100)%)",
							f = `(${c}|(0?((\\.([\\d]{1,5}))?))|1)`,
							h = `([\\s]{0,5})\\)?)(([\\s]{0,5})(\\/?)([\\s]{1,5})(((${c}))|(0?((\\.([\\d]{1,5}))?))|1))?([\\s]{0,5})\\)`,
							$ =
								"(-?(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-9][0-9]|3[0-5][0-9])((\\.([\\d]{1,5}))?)|360)(deg)?)",
							g = e => {
								if (n(e)) {
									const r = "([\\s]{0,5})([\\d]{1,5})%?([\\s]{0,5}),?",
										t = "((([\\s]{0,5}),?([\\s]{0,5}))|(([\\s]{1,5})))",
										n = new RegExp(
											`^(rgb)a?\\(${r}${t}${r}${t}${r}${t}((\\/?([\\s]{0,5})(0?\\.?([\\d]{1,5})%?([\\s]{0,5}))?|1|0))?\\)$`,
										)
									return e && n.test(e)
								}
								return !1
							},
							y = e => {
								if (n(e)) {
									const r = new RegExp(
										`^(hsl)a?\\((([\\s]{0,5})(${$}|(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-9][0-9]|3[0-9][0-9]|400)grad)|((([0-5])?\\.([\\d]{1,5})|6\\.([0-9]|1[0-9]|2[0-8])|[0-6])rad)|((0?((\\.([\\d]{1,5}))?)|1)turn))((([\\s]{0,5}),([\\s]{0,5}))|(([\\s]{1,5}))))(([\\s]{0,5})(0|${c})((([\\s]{0,5}),([\\s]{0,5}))|(([\\s]{1,5}))))(([\\s]{0,5})(0|${c})([\\s]{0,5})\\)?)(([\\s]{0,5})(\\/?|,?)([\\s]{0,5})(((${c}))|(0?((\\.([\\d]{1,5}))?))|1))?\\)$`,
									)
									return e && r.test(e)
								}
								return !1
							},
							L = e => {
								if (n(e)) {
									const r = new RegExp(
										`^(hwb\\(([\\s]{0,5})${$}([\\s]{1,5}))((0|${c})([\\s]{1,5}))((0|${c})${h}$`,
									)
									return e && r.test(e)
								}
								return !1
							},
							S = e => {
								if (n(e)) {
									const r =
											"(-?(([0-9]|[1-9][0-9]|1[0-5][0-9])((\\.([\\d]{1,5}))?)?|160))",
										t = new RegExp(
											`^(lab\\(([\\s]{0,5})${s}([\\s]{1,5})${r}([\\s]{1,5})${r}${h}$`,
										)
									return e && t.test(e)
								}
								return !1
							},
							m = e => {
								if (n(e)) {
									const o = new RegExp(
										`^lch\\((([\\s]{0,5})((([0-9]|[1-9][0-9])?((\\.([\\d]{1,5}))?)|100)(%)?)([\\s]{1,5})${"" + d}([\\s]{1,5})((${$})|(0|${f})|(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-9][0-9]|3[0-5][0-9])((\\.([\\d]{1,5}))?)|360))([\\s]{0,5})((\\/([\\s]{0,5})${f}))?)\\)$`,
									)
									return e && o.test(e)
								}
								return !1
							},
							G = e => !!((e && u(e)) || g(e) || y(e) || L(e) || S(e) || m(e))
						r.default = e =>
							!!(
								(e && u(e)) ||
								l(e) ||
								i(e) ||
								g(e) ||
								y(e) ||
								L(e) ||
								S(e) ||
								m(e)
							)
					},
				])
			},
		},
		__webpack_module_cache__ = {}
	function __webpack_require__(moduleId) {
		var cachedModule = __webpack_module_cache__[moduleId]
		if (void 0 !== cachedModule) return cachedModule.exports
		var module = (__webpack_module_cache__[moduleId] = { exports: {} })
		__webpack_modules__[moduleId](module, module.exports, __webpack_require__)
		return module.exports
	}
	__webpack_require__.n = module => {
		var getter =
			module && module.__esModule ? () => module.default : () => module
		__webpack_require__.d(getter, { a: getter })
		return getter
	}
	__webpack_require__.d = (exports, definition) => {
		for (var key in definition)
			__webpack_require__.o(definition, key) &&
				!__webpack_require__.o(exports, key) &&
				Object.defineProperty(exports, key, {
					enumerable: !0,
					get: definition[key],
				})
	}
	__webpack_require__.o = (obj, prop) =>
		Object.prototype.hasOwnProperty.call(obj, prop)
	;(() => {
		"use strict"
		const Function_dual = function (arity, body) {
				if ("function" == typeof arity)
					return function () {
						return arity(arguments)
							? body.apply(this, arguments)
							: self => body(self, ...arguments)
					}
				switch (arity) {
					case 0:
					case 1:
						throw new RangeError(`Invalid arity ${arity}`)
					case 2:
						return function (a, b) {
							return arguments.length >= 2
								? body(a, b)
								: function (self) {
										return body(self, a)
									}
						}
					case 3:
						return function (a, b, c) {
							return arguments.length >= 3
								? body(a, b, c)
								: function (self) {
										return body(self, a, b)
									}
						}
					case 4:
						return function (a, b, c, d) {
							return arguments.length >= 4
								? body(a, b, c, d)
								: function (self) {
										return body(self, a, b, c)
									}
						}
					case 5:
						return function (a, b, c, d, e) {
							return arguments.length >= 5
								? body(a, b, c, d, e)
								: function (self) {
										return body(self, a, b, c, d)
									}
						}
					default:
						return function () {
							if (arguments.length >= arity) return body.apply(this, arguments)
							const args = arguments
							return function (self) {
								return body(self, ...args)
							}
						}
				}
			},
			apply = a => self => self(a),
			Function_identity = a => a,
			constant = value => () => value,
			Function_constTrue = constant(!0),
			constFalse = constant(!1),
			Function_constUndefined = constant(void 0),
			Function_constVoid = Function_constUndefined,
			flip =
				f =>
				(...b) =>
				(...a) =>
					f(...a)(...b)
		function Function_pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
			switch (arguments.length) {
				case 1:
					return a
				case 2:
					return ab(a)
				case 3:
					return bc(ab(a))
				case 4:
					return cd(bc(ab(a)))
				case 5:
					return de(cd(bc(ab(a))))
				case 6:
					return ef(de(cd(bc(ab(a)))))
				case 7:
					return fg(ef(de(cd(bc(ab(a))))))
				case 8:
					return gh(fg(ef(de(cd(bc(ab(a)))))))
				case 9:
					return hi(gh(fg(ef(de(cd(bc(ab(a))))))))
				default: {
					let ret = arguments[0]
					for (let i = 1; i < arguments.length; i++) ret = arguments[i](ret)
					return ret
				}
			}
		}
		const getCurrentVersion = () => "3.5.7",
			globalStoreId = Symbol.for(
				`effect/GlobalValue/globalStoreId/${getCurrentVersion()}`,
			)
		globalStoreId in globalThis || (globalThis[globalStoreId] = new Map())
		const globalStore = globalThis[globalStoreId],
			globalValue = (id, compute) => {
				globalStore.has(id) || globalStore.set(id, compute())
				return globalStore.get(id)
			},
			isTruthy = input => !!input,
			isString = input => "string" == typeof input,
			isNumber = input => "number" == typeof input,
			Predicate_isBoolean = input => "boolean" == typeof input,
			isBigInt = input => "bigint" == typeof input,
			isSymbol = input => "symbol" == typeof input,
			Predicate_isFunction = input => "function" == typeof input,
			isUndefined = input => void 0 === input,
			isNever = _ => !1,
			isRecordOrArray = input => "object" == typeof input && null !== input,
			Predicate_isObject = input =>
				isRecordOrArray(input) || Predicate_isFunction(input),
			Predicate_hasProperty = Function_dual(
				2,
				(self, property) => Predicate_isObject(self) && property in self,
			),
			Predicate_isTagged = Function_dual(
				2,
				(self, tag) => Predicate_hasProperty(self, "_tag") && self._tag === tag,
			),
			isNullable = input => null == input,
			isNotNullable = input => null != input,
			Predicate_isIterable = input =>
				Predicate_hasProperty(input, Symbol.iterator),
			isRecord = input => isRecordOrArray(input) && !Array.isArray(input),
			not = self => a => !self(a),
			getBugErrorMessage = message =>
				`BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`
		Symbol.iterator
		class SingleShotGen {
			self
			called = !1
			constructor(self) {
				this.self = self
			}
			next(a) {
				return this.called
					? { value: a, done: !0 }
					: ((this.called = !0), { value: this.self, done: !1 })
			}
			return(a) {
				return { value: a, done: !0 }
			}
			throw(e) {
				throw e
			}
			[Symbol.iterator]() {
				return new SingleShotGen(this.self)
			}
		}
		class PCGRandom {
			_state
			constructor(seedHi, seedLo, incHi, incLo) {
				if (isNullable(seedLo) && isNullable(seedHi)) {
					seedLo = (4294967295 * Math.random()) >>> 0
					seedHi = 0
				} else if (isNullable(seedLo)) {
					seedLo = seedHi
					seedHi = 0
				}
				if (isNullable(incLo) && isNullable(incHi)) {
					incLo = this._state ? this._state[3] : 4150755663
					incHi = this._state ? this._state[2] : 335903614
				} else if (isNullable(incLo)) {
					incLo = incHi
					incHi = 0
				}
				this._state = new Int32Array([
					0,
					0,
					incHi >>> 0,
					(1 | (incLo || 0)) >>> 0,
				])
				this._next()
				add64(
					this._state,
					this._state[0],
					this._state[1],
					seedHi >>> 0,
					seedLo >>> 0,
				)
				this._next()
				return this
			}
			getState() {
				return [this._state[0], this._state[1], this._state[2], this._state[3]]
			}
			setState(state) {
				this._state[0] = state[0]
				this._state[1] = state[1]
				this._state[2] = state[2]
				this._state[3] = 1 | state[3]
			}
			integer(max) {
				if (!max) return this._next()
				if (0 == ((max >>>= 0) & (max - 1))) return this._next() & (max - 1)
				let num = 0
				const skew = (-max >>> 0) % max >>> 0
				for (num = this._next(); num < skew; num = this._next());
				return num % max
			}
			number() {
				return (
					(1 * (67108863 & this._next()) * 134217728 +
						1 * (134217727 & this._next())) /
					9007199254740992
				)
			}
			_next() {
				const oldHi = this._state[0] >>> 0,
					oldLo = this._state[1] >>> 0
				!(function (out, aHi, aLo, bHi, bLo) {
					let c1 = (32557 * (aLo >>> 16)) >>> 0,
						c0 = (19605 * (65535 & aLo)) >>> 0,
						lo = (32557 * (65535 & aLo)) >>> 0,
						hi = (19605 * (aLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16))) >>> 0
					c0 = (c0 << 16) >>> 0
					lo = (lo + c0) >>> 0
					lo >>> 0 < c0 >>> 0 && (hi = (hi + 1) >>> 0)
					c1 = (c1 << 16) >>> 0
					lo = (lo + c1) >>> 0
					lo >>> 0 < c1 >>> 0 && (hi = (hi + 1) >>> 0)
					hi = (hi + Math.imul(aLo, 1481765933)) >>> 0
					hi = (hi + Math.imul(aHi, 1284865837)) >>> 0
					out[0] = hi
					out[1] = lo
				})(this._state, oldHi, oldLo)
				add64(
					this._state,
					this._state[0],
					this._state[1],
					this._state[2],
					this._state[3],
				)
				let xsHi = oldHi >>> 18,
					xsLo = ((oldLo >>> 18) | (oldHi << 14)) >>> 0
				xsHi = (xsHi ^ oldHi) >>> 0
				xsLo = (xsLo ^ oldLo) >>> 0
				const xorshifted = ((xsLo >>> 27) | (xsHi << 5)) >>> 0,
					rot = oldHi >>> 27
				return (
					((xorshifted >>> rot) |
						(xorshifted << (((-rot >>> 0) & 31) >>> 0))) >>>
					0
				)
			}
		}
		function add64(out, aHi, aLo, bHi, bLo) {
			let hi = (aHi + bHi) >>> 0
			const lo = (aLo + bLo) >>> 0
			lo >>> 0 < aLo >>> 0 && (hi = (hi + 1) | 0)
			out[0] = hi
			out[1] = lo
		}
		const YieldWrapTypeId = Symbol.for("effect/Utils/YieldWrap")
		class YieldWrap {
			#value
			constructor(value) {
				this.#value = value
			}
			[YieldWrapTypeId]() {
				return this.#value
			}
		}
		const structuralRegionState = globalValue(
				"effect/Utils/isStructuralRegion",
				() => ({ enabled: !1, tester: void 0 }),
			),
			internalCall = (name => {
				const wrap = { [name]: body => body() }
				return function (fn) {
					return wrap[name](fn)
				}
			})("effect_internal_function"),
			randomHashCache = globalValue(
				Symbol.for("effect/Hash/randomHashCache"),
				() => new WeakMap(),
			),
			symbol = Symbol.for("effect/Hash"),
			Hash_hash = self => {
				if (!0 === structuralRegionState.enabled) return 0
				switch (typeof self) {
					case "number":
						return Hash_number(self)
					case "bigint":
						return string(self.toString(10))
					case "boolean":
					case "symbol":
						return string(String(self))
					case "string":
						return string(self)
					case "undefined":
						return string("undefined")
					case "function":
					case "object":
						return null === self
							? string("null")
							: self instanceof Date
								? Hash_hash(self.toISOString())
								: isHash(self)
									? self[symbol]()
									: random(self)
					default:
						throw new Error(
							`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`,
						)
				}
			},
			random = self => {
				randomHashCache.has(self) ||
					randomHashCache.set(
						self,
						Hash_number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)),
					)
				return randomHashCache.get(self)
			},
			combine = b => self => (53 * self) ^ b,
			optimize = n => (3221225471 & n) | ((n >>> 1) & 1073741824),
			isHash = u => Predicate_hasProperty(u, symbol),
			Hash_number = n => {
				if (n != n || n === 1 / 0) return 0
				let h = 0 | n
				h !== n && (h ^= 4294967295 * n)
				for (; n > 4294967295; ) h ^= n /= 4294967295
				return optimize(n)
			},
			string = str => {
				let h = 5381,
					i = str.length
				for (; i; ) h = (33 * h) ^ str.charCodeAt(--i)
				return optimize(h)
			},
			structure = o =>
				((o, keys) => {
					let h = 12289
					for (let i = 0; i < keys.length; i++)
						h ^= Function_pipe(string(keys[i]), combine(Hash_hash(o[keys[i]])))
					return optimize(h)
				})(o, Object.keys(o)),
			array = arr => {
				let h = 6151
				for (let i = 0; i < arr.length; i++)
					h = Function_pipe(h, combine(Hash_hash(arr[i])))
				return optimize(h)
			},
			cached = function () {
				if (1 === arguments.length) {
					const self = arguments[0]
					return function (hash) {
						Object.defineProperty(self, symbol, {
							value: () => hash,
							enumerable: !1,
						})
						return hash
					}
				}
				const self = arguments[0],
					hash = arguments[1]
				Object.defineProperty(self, symbol, {
					value: () => hash,
					enumerable: !1,
				})
				return hash
			},
			Equal_symbol = Symbol.for("effect/Equal")
		function equals() {
			return 1 === arguments.length
				? self => compareBoth(self, arguments[0])
				: compareBoth(arguments[0], arguments[1])
		}
		function compareBoth(self, that) {
			if (self === that) return !0
			const selfType = typeof self
			if (selfType !== typeof that) return !1
			if ("object" === selfType || "function" === selfType) {
				if (null !== self && null !== that) {
					if (isEqual(self) && isEqual(that))
						return (
							!(
								Hash_hash(self) !== Hash_hash(that) || !self[Equal_symbol](that)
							) ||
							(!(
								!structuralRegionState.enabled || !structuralRegionState.tester
							) &&
								structuralRegionState.tester(self, that))
						)
					if (self instanceof Date && that instanceof Date)
						return self.toISOString() === that.toISOString()
				}
				if (structuralRegionState.enabled) {
					if (Array.isArray(self) && Array.isArray(that))
						return (
							self.length === that.length &&
							self.every((v, i) => compareBoth(v, that[i]))
						)
					if (
						Object.getPrototypeOf(self) === Object.prototype &&
						Object.getPrototypeOf(self) === Object.prototype
					) {
						const keysSelf = Object.keys(self),
							keysThat = Object.keys(that)
						if (keysSelf.length === keysThat.length) {
							for (const key of keysSelf)
								if (!(key in that) || !compareBoth(self[key], that[key]))
									return (
										!!structuralRegionState.tester &&
										structuralRegionState.tester(self, that)
									)
							return !0
						}
					}
					return (
						!!structuralRegionState.tester &&
						structuralRegionState.tester(self, that)
					)
				}
			}
			return (
				!(!structuralRegionState.enabled || !structuralRegionState.tester) &&
				structuralRegionState.tester(self, that)
			)
		}
		const isEqual = u => Predicate_hasProperty(u, Equal_symbol),
			equivalence = () => equals,
			Inspectable_NodeInspectSymbol = Symbol.for("nodejs.util.inspect.custom"),
			toJSON = x =>
				Predicate_hasProperty(x, "toJSON") &&
				Predicate_isFunction(x.toJSON) &&
				0 === x.toJSON.length
					? x.toJSON()
					: Array.isArray(x)
						? x.map(toJSON)
						: x,
			format = x => JSON.stringify(x, null, 2),
			toStringUnknown = (u, whitespace = 2) => {
				try {
					return "object" == typeof u
						? stringifyCircular(u, whitespace)
						: String(u)
				} catch (_) {
					return String(u)
				}
			},
			stringifyCircular = (obj, whitespace) => {
				let cache = []
				const retVal = JSON.stringify(
					obj,
					(_key, value) =>
						"object" == typeof value && null !== value
							? cache.includes(value)
								? void 0
								: cache.push(value) && value
							: value,
					whitespace,
				)
				cache = void 0
				return retVal
			},
			Pipeable_pipeArguments = (self, args) => {
				switch (args.length) {
					case 1:
						return args[0](self)
					case 2:
						return args[1](args[0](self))
					case 3:
						return args[2](args[1](args[0](self)))
					case 4:
						return args[3](args[2](args[1](args[0](self))))
					case 5:
						return args[4](args[3](args[2](args[1](args[0](self)))))
					case 6:
						return args[5](args[4](args[3](args[2](args[1](args[0](self))))))
					case 7:
						return args[6](
							args[5](args[4](args[3](args[2](args[1](args[0](self)))))),
						)
					case 8:
						return args[7](
							args[6](
								args[5](args[4](args[3](args[2](args[1](args[0](self)))))),
							),
						)
					case 9:
						return args[8](
							args[7](
								args[6](
									args[5](args[4](args[3](args[2](args[1](args[0](self)))))),
								),
							),
						)
					default: {
						let ret = self
						for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret)
						return ret
					}
				}
			},
			EffectTypeId = Symbol.for("effect/Effect"),
			StreamTypeId = Symbol.for("effect/Stream"),
			SinkTypeId = Symbol.for("effect/Sink"),
			ChannelTypeId = Symbol.for("effect/Channel"),
			effectVariance = {
				_R: _ => _,
				_E: _ => _,
				_A: _ => _,
				_V: getCurrentVersion(),
			},
			EffectPrototype = {
				[EffectTypeId]: effectVariance,
				[StreamTypeId]: effectVariance,
				[SinkTypeId]: {
					_A: _ => _,
					_In: _ => _,
					_L: _ => _,
					_E: _ => _,
					_R: _ => _,
				},
				[ChannelTypeId]: {
					_Env: _ => _,
					_InErr: _ => _,
					_InElem: _ => _,
					_InDone: _ => _,
					_OutErr: _ => _,
					_OutElem: _ => _,
					_OutDone: _ => _,
				},
				[Equal_symbol](that) {
					return this === that
				},
				[symbol]() {
					return cached(this, random(this))
				},
				[Symbol.iterator]() {
					return new SingleShotGen(new YieldWrap(this))
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			effectable_StructuralPrototype = {
				[symbol]() {
					return cached(this, structure(this))
				},
				[Equal_symbol](that) {
					const selfKeys = Object.keys(this),
						thatKeys = Object.keys(that)
					if (selfKeys.length !== thatKeys.length) return !1
					for (const key of selfKeys)
						if (!(key in that) || !equals(this[key], that[key])) return !1
					return !0
				},
			},
			StructuralCommitPrototype = {
				...{ ...EffectPrototype, _op: "Commit" },
				...effectable_StructuralPrototype,
			},
			TypeId = Symbol.for("effect/Option"),
			CommonProto = {
				...EffectPrototype,
				[TypeId]: { _A: _ => _ },
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				toString() {
					return format(this.toJSON())
				},
			},
			SomeProto = Object.assign(Object.create(CommonProto), {
				_tag: "Some",
				_op: "Some",
				[Equal_symbol](that) {
					return (
						isOption(that) && isSome(that) && equals(this.value, that.value)
					)
				},
				[symbol]() {
					return cached(
						this,
						combine(Hash_hash(this._tag))(Hash_hash(this.value)),
					)
				},
				toJSON() {
					return { _id: "Option", _tag: this._tag, value: toJSON(this.value) }
				},
			}),
			NoneHash = Hash_hash("None"),
			NoneProto = Object.assign(Object.create(CommonProto), {
				_tag: "None",
				_op: "None",
				[Equal_symbol]: that => isOption(that) && isNone(that),
				[symbol]: () => NoneHash,
				toJSON() {
					return { _id: "Option", _tag: this._tag }
				},
			}),
			isOption = input => Predicate_hasProperty(input, TypeId),
			isNone = fa => "None" === fa._tag,
			isSome = fa => "Some" === fa._tag,
			none = Object.create(NoneProto),
			option_some = value => {
				const a = Object.create(SomeProto)
				a.value = value
				return a
			},
			TagTypeId = Symbol.for("effect/Context/Tag"),
			STMTypeId = Symbol.for("effect/STM"),
			context_TagProto = {
				...EffectPrototype,
				_tag: "Tag",
				_op: "Tag",
				[STMTypeId]: effectVariance,
				[TagTypeId]: { _Service: _ => _, _Identifier: _ => _ },
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "Tag", key: this.key, stack: this.stack }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				of: self => self,
				context(self) {
					return make(this, self)
				},
			},
			context_TypeId = Symbol.for("effect/Context"),
			ContextProto = {
				[context_TypeId]: { _Services: _ => _ },
				[Equal_symbol](that) {
					if (isContext(that) && this.unsafeMap.size === that.unsafeMap.size) {
						for (const k of this.unsafeMap.keys())
							if (
								!that.unsafeMap.has(k) ||
								!equals(this.unsafeMap.get(k), that.unsafeMap.get(k))
							)
								return !1
						return !0
					}
					return !1
				},
				[symbol]() {
					return cached(this, Hash_number(this.unsafeMap.size))
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return {
						_id: "Context",
						services: Array.from(this.unsafeMap).map(toJSON),
					}
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
			},
			makeContext = unsafeMap => {
				const context = Object.create(ContextProto)
				context.unsafeMap = unsafeMap
				return context
			},
			isContext = u => Predicate_hasProperty(u, context_TypeId),
			_empty = makeContext(new Map()),
			make = (tag, service) => makeContext(new Map([[tag.key, service]])),
			add = Function_dual(3, (self, tag, service) => {
				const map = new Map(self.unsafeMap)
				map.set(tag.key, service)
				return makeContext(map)
			}),
			unsafeGet = Function_dual(2, (self, tag) => {
				if (!self.unsafeMap.has(tag.key))
					throw (tag => {
						const error = new Error(
							"Service not found" + (tag.key ? `: ${String(tag.key)}` : ""),
						)
						if (tag.stack) {
							const lines = tag.stack.split("\n")
							if (lines.length > 2) {
								const afterAt = lines[2].match(/at (.*)/)
								afterAt &&
									(error.message =
										error.message + ` (defined at ${afterAt[1]})`)
							}
						}
						if (error.stack) {
							const lines = error.stack.split("\n")
							lines.splice(1, 3)
							error.stack = lines.join("\n")
						}
						return error
					})(tag)
				return self.unsafeMap.get(tag.key)
			}),
			get = unsafeGet,
			getOption = Function_dual(2, (self, tag) =>
				self.unsafeMap.has(tag.key)
					? option_some(self.unsafeMap.get(tag.key))
					: none,
			),
			merge = Function_dual(2, (self, that) => {
				const map = new Map(self.unsafeMap)
				for (const [tag, s] of that.unsafeMap) map.set(tag, s)
				return makeContext(map)
			}),
			GenericTag = key => {
				const limit = Error.stackTraceLimit
				Error.stackTraceLimit = 2
				const creationError = new Error()
				Error.stackTraceLimit = limit
				const tag = Object.create(context_TagProto)
				Object.defineProperty(tag, "stack", { get: () => creationError.stack })
				tag.key = key
				return tag
			},
			Context_isContext = isContext,
			Context_empty = () => _empty,
			Context_make = make,
			Context_add = add,
			Context_get = get,
			Context_unsafeGet = unsafeGet,
			Context_getOption = getOption,
			Context_merge = merge,
			Equivalence_make = isEquivalent => (self, that) =>
				self === that || isEquivalent(self, that),
			isStrictEquivalent = (x, y) => x === y,
			strict = () => isStrictEquivalent,
			Equivalence_string = strict(),
			Equivalence_mapInput = Function_dual(2, (self, f) =>
				Equivalence_make((x, y) => self(f(x), f(y))),
			),
			isNonEmptyArray = self => self.length > 0,
			either_TypeId = Symbol.for("effect/Either"),
			either_CommonProto = {
				...EffectPrototype,
				[either_TypeId]: { _R: _ => _ },
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				toString() {
					return format(this.toJSON())
				},
			},
			RightProto = Object.assign(Object.create(either_CommonProto), {
				_tag: "Right",
				_op: "Right",
				[Equal_symbol](that) {
					return (
						isEither(that) && isRight(that) && equals(this.right, that.right)
					)
				},
				[symbol]() {
					return combine(Hash_hash(this._tag))(Hash_hash(this.right))
				},
				toJSON() {
					return { _id: "Either", _tag: this._tag, right: toJSON(this.right) }
				},
			}),
			LeftProto = Object.assign(Object.create(either_CommonProto), {
				_tag: "Left",
				_op: "Left",
				[Equal_symbol](that) {
					return isEither(that) && isLeft(that) && equals(this.left, that.left)
				},
				[symbol]() {
					return combine(Hash_hash(this._tag))(Hash_hash(this.left))
				},
				toJSON() {
					return { _id: "Either", _tag: this._tag, left: toJSON(this.left) }
				},
			}),
			isEither = input => Predicate_hasProperty(input, either_TypeId),
			isLeft = ma => "Left" === ma._tag,
			isRight = ma => "Right" === ma._tag,
			Option_none = () => none,
			Option_some = option_some,
			Option_isNone = isNone,
			Option_isSome = isSome,
			match = Function_dual(2, (self, { onNone, onSome }) =>
				Option_isNone(self) ? onNone() : onSome(self.value),
			),
			getOrElse = Function_dual(2, (self, onNone) =>
				Option_isNone(self) ? onNone() : self.value,
			),
			orElse = Function_dual(2, (self, that) =>
				Option_isNone(self) ? that() : self,
			),
			orElseSome = Function_dual(2, (self, onNone) =>
				Option_isNone(self) ? Option_some(onNone()) : self,
			),
			fromNullable = nullableValue =>
				null == nullableValue ? Option_none() : Option_some(nullableValue),
			getOrUndefined = getOrElse(Function_constUndefined),
			getOrThrow = Function_dual(2, (self, onNone) => {
				if (Option_isSome(self)) return self.value
				throw onNone()
			})(() => new Error("getOrThrow called on a None")),
			map = Function_dual(2, (self, f) =>
				Option_isNone(self) ? Option_none() : Option_some(f(self.value)),
			),
			flatMap = Function_dual(2, (self, f) =>
				Option_isNone(self) ? Option_none() : f(self.value),
			),
			flatMapNullable = Function_dual(2, (self, f) =>
				Option_isNone(self) ? Option_none() : fromNullable(f(self.value)),
			),
			filterMap = Function_dual(2, (self, f) =>
				Option_isNone(self) ? Option_none() : f(self.value),
			),
			filter = Function_dual(2, (self, predicate) =>
				filterMap(self, b => (predicate(b) ? option_some(b) : none)),
			),
			liftPredicate = Function_dual(2, (b, predicate) =>
				predicate(b) ? Option_some(b) : Option_none(),
			),
			containsWith = isEquivalent =>
				Function_dual(
					2,
					(self, a) => !Option_isNone(self) && isEquivalent(self.value, a),
				),
			contains = containsWith(equivalence()),
			exists = Function_dual(
				2,
				(self, refinement) => !Option_isNone(self) && refinement(self.value),
			),
			findFirst = Function_dual(2, (self, f) => {
				let i = 0
				for (const a of self) {
					const o = f(a, i)
					if (Predicate_isBoolean(o)) {
						if (o) return Option_some(a)
					} else if (Option_isSome(o)) return o
					i++
				}
				return Option_none()
			})
		Symbol.iterator
		const Order_make = compare => (self, that) =>
				self === that ? 0 : compare(self, that),
			Order_number = Order_make((self, that) => (self < that ? -1 : 1)),
			Order_boolean = Order_make((self, that) => (self < that ? -1 : 1)),
			Order_mapInput = Function_dual(2, (self, f) =>
				Order_make((b1, b2) => self(f(b1), f(b2))),
			),
			greaterThan = O => Function_dual(2, (self, that) => 1 === O(self, that)),
			greaterThanOrEqualTo = O =>
				Function_dual(2, (self, that) => -1 !== O(self, that)),
			clamp = O =>
				Function_dual(2, (self, options) =>
					(O =>
						Function_dual(2, (self, that) =>
							self === that || O(self, that) < 1 ? self : that,
						))(O)(
						options.maximum,
						(O =>
							Function_dual(2, (self, that) =>
								self === that || O(self, that) > -1 ? self : that,
							))(O)(options.minimum, self),
					),
				),
			Tuple_make = (Object.fromEntries, (...elements) => elements),
			getFirst = self => self[0],
			getSecond = self => self[1],
			mapBoth = Function_dual(2, (self, { onFirst, onSecond }) => [
				onFirst(self[0]),
				onSecond(self[1]),
			]),
			mapFirst = Function_dual(2, (self, f) => [f(self[0]), self[1]]),
			mapSecond = Function_dual(2, (self, f) => [self[0], f(self[1])]),
			allocate = n => new Array(n),
			Array_makeBy = (n, f) => {
				const max = Math.max(1, Math.floor(n)),
					out = new Array(max)
				for (let i = 0; i < max; i++) out[i] = f(i)
				return out
			},
			Array_fromIterable = collection =>
				Array.isArray(collection) ? collection : Array.from(collection),
			matchLeft = Function_dual(2, (self, { onEmpty, onNonEmpty }) =>
				isNonEmptyReadonlyArray(self)
					? onNonEmpty(headNonEmpty(self), tailNonEmpty(self))
					: onEmpty(),
			),
			matchRight = Function_dual(2, (self, { onEmpty, onNonEmpty }) =>
				isNonEmptyReadonlyArray(self)
					? onNonEmpty(initNonEmpty(self), lastNonEmpty(self))
					: onEmpty(),
			),
			Array_prepend = Function_dual(2, (self, head) => [head, ...self]),
			Array_append = Function_dual(2, (self, last) => [...self, last]),
			Array_appendAll = Function_dual(2, (self, that) =>
				Array_fromIterable(self).concat(Array_fromIterable(that)),
			),
			isArray = Array.isArray,
			Array_isNonEmptyArray = isNonEmptyArray,
			isNonEmptyReadonlyArray = isNonEmptyArray,
			isOutOfBound = (i, as) => i < 0 || i >= as.length,
			Array_clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length)),
			Array_get = Function_dual(2, (self, index) => {
				const i = Math.floor(index)
				return isOutOfBound(i, self) ? Option_none() : Option_some(self[i])
			}),
			Array_unsafeGet = Function_dual(2, (self, index) => {
				const i = Math.floor(index)
				if (isOutOfBound(i, self)) throw new Error(`Index ${i} out of bounds`)
				return self[i]
			}),
			Array_head = Array_get(0),
			headNonEmpty = Array_unsafeGet(0),
			lastNonEmpty = self => self[self.length - 1],
			tailNonEmpty = self => self.slice(1),
			initNonEmpty = self => self.slice(0, -1),
			Array_take = Function_dual(2, (self, n) => {
				const input = Array_fromIterable(self)
				return input.slice(0, Array_clamp(n, input))
			}),
			span = Function_dual(2, (self, predicate) =>
				splitAt(
					self,
					((self, predicate) => {
						let i = 0
						for (const a of self) {
							if (!predicate(a, i)) break
							i++
						}
						return i
					})(self, predicate),
				),
			),
			Array_drop = Function_dual(2, (self, n) => {
				const input = Array_fromIterable(self)
				return input.slice(Array_clamp(n, input), input.length)
			}),
			findFirstIndex = Function_dual(2, (self, predicate) => {
				let i = 0
				for (const a of self) {
					if (predicate(a, i)) return Option_some(i)
					i++
				}
				return Option_none()
			}),
			Array_findFirst = findFirst,
			Array_findLast = Function_dual(2, (self, f) => {
				const input = Array_fromIterable(self)
				for (let i = input.length - 1; i >= 0; i--) {
					const a = input[i],
						o = f(a, i)
					if (Predicate_isBoolean(o)) {
						if (o) return Option_some(a)
					} else if (Option_isSome(o)) return o
				}
				return Option_none()
			}),
			Array_replace = Function_dual(3, (self, i, b) =>
				Array_modify(self, i, () => b),
			),
			Array_modify = Function_dual(3, (self, i, f) =>
				getOrElse(Array_modifyOption(self, i, f), () => Array.from(self)),
			),
			Array_modifyOption = Function_dual(3, (self, i, f) => {
				const out = Array.from(self)
				if (isOutOfBound(i, out)) return Option_none()
				const next = f(out[i])
				out[i] = next
				return Option_some(out)
			}),
			Array_remove = Function_dual(2, (self, i) => {
				const out = Array.from(self)
				if (isOutOfBound(i, out)) return out
				out.splice(i, 1)
				return out
			}),
			Array_reverse = self => Array.from(self).reverse(),
			sort = Function_dual(2, (self, O) => {
				const out = Array.from(self)
				out.sort(O)
				return out
			}),
			Array_zip = Function_dual(2, (self, that) =>
				Array_zipWith(self, that, Tuple_make),
			),
			Array_zipWith = Function_dual(3, (self, that, f) => {
				const as = Array_fromIterable(self),
					bs = Array_fromIterable(that)
				if (isNonEmptyReadonlyArray(as) && isNonEmptyReadonlyArray(bs)) {
					const out = [f(headNonEmpty(as), headNonEmpty(bs))],
						len = Math.min(as.length, bs.length)
					for (let i = 1; i < len; i++) out[i] = f(as[i], bs[i])
					return out
				}
				return []
			}),
			Array_containsWith = isEquivalent =>
				Function_dual(2, (self, a) => {
					for (const i of self) if (isEquivalent(a, i)) return !0
					return !1
				}),
			Array_equivalence = equivalence(),
			splitAt = Function_dual(2, (self, n) => {
				const input = Array.from(self),
					_n = Math.floor(n)
				return isNonEmptyReadonlyArray(input)
					? _n >= 1
						? splitNonEmptyAt(input, _n)
						: [[], input]
					: [input, []]
			}),
			splitNonEmptyAt = Function_dual(2, (self, n) => {
				const _n = Math.max(1, Math.floor(n))
				return _n >= self.length
					? [copy(self), []]
					: [
							Array_prepend(self.slice(1, _n), headNonEmpty(self)),
							self.slice(_n),
						]
			}),
			copy = self => self.slice(),
			unionWith = Function_dual(3, (self, that, isEquivalent) => {
				const a = Array_fromIterable(self),
					b = Array_fromIterable(that)
				return isNonEmptyReadonlyArray(a)
					? isNonEmptyReadonlyArray(b)
						? dedupeWith(isEquivalent)(Array_appendAll(a, b))
						: a
					: b
			}),
			Array_union = Function_dual(2, (self, that) =>
				unionWith(self, that, Array_equivalence),
			),
			Array_of = a => [a],
			Array_map = Function_dual(2, (self, f) => self.map(f)),
			Array_flatMap = Function_dual(2, (self, f) => {
				if ((self => 0 === self.length)(self)) return []
				const out = []
				for (let i = 0; i < self.length; i++) {
					const inner = f(self[i], i)
					for (let j = 0; j < inner.length; j++) out.push(inner[j])
				}
				return out
			}),
			Array_flatten = Array_flatMap(Function_identity),
			Array_filterMap = Function_dual(2, (self, f) => {
				const as = Array_fromIterable(self),
					out = []
				for (let i = 0; i < as.length; i++) {
					const o = f(as[i], i)
					Option_isSome(o) && out.push(o.value)
				}
				return out
			}),
			Array_getSomes = Array_filterMap(Function_identity),
			Array_filter = Function_dual(2, (self, predicate) => {
				const as = Array_fromIterable(self),
					out = []
				for (let i = 0; i < as.length; i++)
					predicate(as[i], i) && out.push(as[i])
				return out
			}),
			Array_reduce = Function_dual(3, (self, b, f) =>
				Array_fromIterable(self).reduce((b, a, i) => f(b, a, i), b),
			),
			Array_some = Function_dual(2, (self, predicate) => self.some(predicate)),
			Array_unfold = (b, f) => {
				const out = []
				let o,
					next = b
				for (; Option_isSome((o = f(next))); ) {
					const [a, b] = o.value
					out.push(a)
					next = b
				}
				return out
			},
			Array_getEquivalence = item =>
				Equivalence_make((self, that) => {
					if (self.length !== that.length) return !1
					for (let i = 0; i < self.length; i++)
						if (!item(self[i], that[i])) return !1
					return !0
				}),
			dedupeWith = Function_dual(2, (self, isEquivalent) => {
				const input = Array_fromIterable(self)
				if (isNonEmptyReadonlyArray(input)) {
					const out = [headNonEmpty(input)],
						rest = tailNonEmpty(input)
					for (const r of rest)
						out.every(a => !isEquivalent(r, a)) && out.push(r)
					return out
				}
				return []
			}),
			dedupe = self => dedupeWith(self, equivalence()),
			join = Function_dual(2, (self, sep) =>
				Array_fromIterable(self).join(sep),
			),
			Chunk_TypeId = Symbol.for("effect/Chunk"),
			emptyArray = [],
			Chunk_getEquivalence = isEquivalent =>
				Equivalence_make(
					(self, that) =>
						self.length === that.length &&
						toReadonlyArray(self).every((value, i) =>
							isEquivalent(value, Chunk_unsafeGet(that, i)),
						),
				),
			Chunk_equivalence = Chunk_getEquivalence(equals),
			ChunkProto = {
				[Chunk_TypeId]: { _A: _ => _ },
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "Chunk", values: toReadonlyArray(this).map(toJSON) }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				[Equal_symbol](that) {
					return isChunk(that) && Chunk_equivalence(this, that)
				},
				[symbol]() {
					return cached(this, array(toReadonlyArray(this)))
				},
				[Symbol.iterator]() {
					switch (this.backing._tag) {
						case "IArray":
							return this.backing.array[Symbol.iterator]()
						case "IEmpty":
							return emptyArray[Symbol.iterator]()
						default:
							return toReadonlyArray(this)[Symbol.iterator]()
					}
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			makeChunk = backing => {
				const chunk = Object.create(ChunkProto)
				chunk.backing = backing
				switch (backing._tag) {
					case "IEmpty":
						chunk.length = 0
						chunk.depth = 0
						chunk.left = chunk
						chunk.right = chunk
						break
					case "IConcat":
						chunk.length = backing.left.length + backing.right.length
						chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth)
						chunk.left = backing.left
						chunk.right = backing.right
						break
					case "IArray":
						chunk.length = backing.array.length
						chunk.depth = 0
						chunk.left = Chunk_empty
						chunk.right = Chunk_empty
						break
					case "ISingleton":
						chunk.length = 1
						chunk.depth = 0
						chunk.left = Chunk_empty
						chunk.right = Chunk_empty
						break
					case "ISlice":
						chunk.length = backing.length
						chunk.depth = backing.chunk.depth + 1
						chunk.left = Chunk_empty
						chunk.right = Chunk_empty
				}
				return chunk
			},
			isChunk = u => Predicate_hasProperty(u, Chunk_TypeId),
			Chunk_empty = makeChunk({ _tag: "IEmpty" }),
			esm_Chunk_empty = () => Chunk_empty,
			Chunk_make = (...as) =>
				1 === as.length ? Chunk_of(as[0]) : unsafeFromNonEmptyArray(as),
			Chunk_of = a => makeChunk({ _tag: "ISingleton", a }),
			Chunk_fromIterable = self =>
				isChunk(self)
					? self
					: makeChunk({ _tag: "IArray", array: Array_fromIterable(self) }),
			copyToArray = (self, array, initial) => {
				switch (self.backing._tag) {
					case "IArray":
						!(function (src, srcPos, dest, destPos, len) {
							for (let i = 0; i < Math.min(src.length, 0 + len); i++)
								dest[destPos + i - 0] = src[i]
						})(self.backing.array, 0, array, initial, self.length)
						break
					case "IConcat":
						copyToArray(self.left, array, initial)
						copyToArray(self.right, array, initial + self.left.length)
						break
					case "ISingleton":
						array[initial] = self.backing.a
						break
					case "ISlice": {
						let i = 0,
							j = initial
						for (; i < self.length; ) {
							array[j] = Chunk_unsafeGet(self, i)
							i += 1
							j += 1
						}
						break
					}
				}
			},
			toReadonlyArray = self => {
				switch (self.backing._tag) {
					case "IEmpty":
						return emptyArray
					case "IArray":
						return self.backing.array
					default: {
						const arr = new Array(self.length)
						copyToArray(self, arr, 0)
						self.backing = { _tag: "IArray", array: arr }
						self.left = Chunk_empty
						self.right = Chunk_empty
						self.depth = 0
						return arr
					}
				}
			},
			Chunk_reverse = self => {
				switch (self.backing._tag) {
					case "IEmpty":
					case "ISingleton":
						return self
					case "IArray":
						return makeChunk({
							_tag: "IArray",
							array: Array_reverse(self.backing.array),
						})
					case "IConcat":
						return makeChunk({
							_tag: "IConcat",
							left: Chunk_reverse(self.backing.right),
							right: Chunk_reverse(self.backing.left),
						})
					case "ISlice":
						return unsafeFromArray(Array_reverse(toReadonlyArray(self)))
				}
			},
			Chunk_get = Function_dual(2, (self, index) =>
				index < 0 || index >= self.length
					? Option_none()
					: Option_some(Chunk_unsafeGet(self, index)),
			),
			unsafeFromArray = self => makeChunk({ _tag: "IArray", array: self }),
			unsafeFromNonEmptyArray = self => unsafeFromArray(self),
			Chunk_unsafeGet = Function_dual(2, (self, index) => {
				switch (self.backing._tag) {
					case "IEmpty":
						throw new Error("Index out of bounds")
					case "ISingleton":
						if (0 !== index) throw new Error("Index out of bounds")
						return self.backing.a
					case "IArray":
						if (index >= self.length || index < 0)
							throw new Error("Index out of bounds")
						return self.backing.array[index]
					case "IConcat":
						return index < self.left.length
							? Chunk_unsafeGet(self.left, index)
							: Chunk_unsafeGet(self.right, index - self.left.length)
					case "ISlice":
						return Chunk_unsafeGet(
							self.backing.chunk,
							index + self.backing.offset,
						)
				}
			}),
			Chunk_append = Function_dual(2, (self, a) =>
				Chunk_appendAll(self, Chunk_of(a)),
			),
			Chunk_prepend = Function_dual(2, (self, elem) =>
				Chunk_appendAll(Chunk_of(elem), self),
			),
			Chunk_drop = Function_dual(2, (self, n) => {
				if (n <= 0) return self
				if (n >= self.length) return Chunk_empty
				switch (self.backing._tag) {
					case "ISlice":
						return makeChunk({
							_tag: "ISlice",
							chunk: self.backing.chunk,
							offset: self.backing.offset + n,
							length: self.backing.length - n,
						})
					case "IConcat":
						return n > self.left.length
							? Chunk_drop(self.right, n - self.left.length)
							: makeChunk({
									_tag: "IConcat",
									left: Chunk_drop(self.left, n),
									right: self.right,
								})
					default:
						return makeChunk({
							_tag: "ISlice",
							chunk: self,
							offset: n,
							length: self.length - n,
						})
				}
			}),
			Chunk_appendAll = Function_dual(2, (self, that) => {
				if ("IEmpty" === self.backing._tag) return that
				if ("IEmpty" === that.backing._tag) return self
				const diff = that.depth - self.depth
				if (Math.abs(diff) <= 1)
					return makeChunk({ _tag: "IConcat", left: self, right: that })
				if (diff < -1) {
					if (self.left.depth >= self.right.depth) {
						const nr = Chunk_appendAll(self.right, that)
						return makeChunk({ _tag: "IConcat", left: self.left, right: nr })
					}
					{
						const nrr = Chunk_appendAll(self.right.right, that)
						if (nrr.depth === self.depth - 3) {
							const nr = makeChunk({
								_tag: "IConcat",
								left: self.right.left,
								right: nrr,
							})
							return makeChunk({ _tag: "IConcat", left: self.left, right: nr })
						}
						{
							const nl = makeChunk({
								_tag: "IConcat",
								left: self.left,
								right: self.right.left,
							})
							return makeChunk({ _tag: "IConcat", left: nl, right: nrr })
						}
					}
				}
				if (that.right.depth >= that.left.depth) {
					const nl = Chunk_appendAll(self, that.left)
					return makeChunk({ _tag: "IConcat", left: nl, right: that.right })
				}
				{
					const nll = Chunk_appendAll(self, that.left.left)
					if (nll.depth === that.depth - 3) {
						const nl = makeChunk({
							_tag: "IConcat",
							left: nll,
							right: that.left.right,
						})
						return makeChunk({ _tag: "IConcat", left: nl, right: that.right })
					}
					{
						const nr = makeChunk({
							_tag: "IConcat",
							left: that.left.right,
							right: that.right,
						})
						return makeChunk({ _tag: "IConcat", left: nll, right: nr })
					}
				}
			}),
			Chunk_isEmpty = self => 0 === self.length,
			isNonEmpty = self => self.length > 0,
			Chunk_head = Chunk_get(0),
			Chunk_unsafeHead = self => Chunk_unsafeGet(self, 0),
			Chunk_headNonEmpty = Chunk_unsafeHead,
			Chunk_tailNonEmpty = self => Chunk_drop(self, 1),
			Duration_TypeId = Symbol.for("effect/Duration"),
			bigint0 = BigInt(0),
			bigint24 = BigInt(24),
			bigint60 = BigInt(60),
			bigint1e3 = BigInt(1e3),
			bigint1e6 = BigInt(1e6),
			bigint1e9 = BigInt(1e9),
			DURATION_REGEX =
				/^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/,
			decode = input => {
				if (isDuration(input)) return input
				if (isNumber(input)) return Duration_millis(input)
				if (isBigInt(input)) return Duration_nanos(input)
				if (Array.isArray(input)) {
					if (2 === input.length && isNumber(input[0]) && isNumber(input[1]))
						return Duration_nanos(
							BigInt(input[0]) * bigint1e9 + BigInt(input[1]),
						)
				} else if (isString(input)) {
					DURATION_REGEX.lastIndex = 0
					const match = DURATION_REGEX.exec(input)
					if (match) {
						const [_, valueStr, unit] = match,
							value = Number(valueStr)
						switch (unit) {
							case "nano":
							case "nanos":
								return Duration_nanos(BigInt(valueStr))
							case "micro":
							case "micros":
								return micros(BigInt(valueStr))
							case "milli":
							case "millis":
								return Duration_millis(value)
							case "second":
							case "seconds":
								return seconds(value)
							case "minute":
							case "minutes":
								return minutes(value)
							case "hour":
							case "hours":
								return hours(value)
							case "day":
							case "days":
								return days(value)
							case "week":
							case "weeks":
								return weeks(value)
						}
					}
				}
				throw new Error("Invalid DurationInput")
			},
			zeroValue = { _tag: "Millis", millis: 0 },
			infinityValue = { _tag: "Infinity" },
			DurationProto = {
				[Duration_TypeId]: Duration_TypeId,
				[symbol]() {
					return cached(this, structure(this.value))
				},
				[Equal_symbol](that) {
					return isDuration(that) && Duration_equals(this, that)
				},
				toString() {
					return `Duration(${Duration_format(this)})`
				},
				toJSON() {
					switch (this.value._tag) {
						case "Millis":
							return {
								_id: "Duration",
								_tag: "Millis",
								millis: this.value.millis,
							}
						case "Nanos":
							return { _id: "Duration", _tag: "Nanos", hrtime: toHrTime(this) }
						case "Infinity":
							return { _id: "Duration", _tag: "Infinity" }
					}
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			Duration_make = input => {
				const duration = Object.create(DurationProto)
				isNumber(input)
					? isNaN(input) || input <= 0
						? (duration.value = zeroValue)
						: Number.isFinite(input)
							? Number.isInteger(input)
								? (duration.value = { _tag: "Millis", millis: input })
								: (duration.value = {
										_tag: "Nanos",
										nanos: BigInt(Math.round(1e6 * input)),
									})
							: (duration.value = infinityValue)
					: (duration.value =
							input <= bigint0 ? zeroValue : { _tag: "Nanos", nanos: input })
				return duration
			},
			isDuration = u => Predicate_hasProperty(u, Duration_TypeId),
			zero = Duration_make(0),
			Duration_nanos = nanos => Duration_make(nanos),
			micros = micros => Duration_make(micros * bigint1e3),
			Duration_millis = millis => Duration_make(millis),
			seconds = seconds => Duration_make(1e3 * seconds),
			minutes = minutes => Duration_make(6e4 * minutes),
			hours = hours => Duration_make(36e5 * hours),
			days = days => Duration_make(864e5 * days),
			weeks = weeks => Duration_make(6048e5 * weeks),
			toMillis = self => {
				const _self = decode(self)
				switch (_self.value._tag) {
					case "Infinity":
						return 1 / 0
					case "Nanos":
						return Number(_self.value.nanos) / 1e6
					case "Millis":
						return _self.value.millis
				}
			},
			toHrTime = self => {
				const _self = decode(self)
				switch (_self.value._tag) {
					case "Infinity":
						return [1 / 0, 0]
					case "Nanos":
						return [
							Number(_self.value.nanos / bigint1e9),
							Number(_self.value.nanos % bigint1e9),
						]
					case "Millis":
						return [
							Math.floor(_self.value.millis / 1e3),
							Math.round((_self.value.millis % 1e3) * 1e6),
						]
				}
			},
			matchWith = Function_dual(3, (self, that, options) => {
				const _self = decode(self),
					_that = decode(that)
				if ("Infinity" === _self.value._tag || "Infinity" === _that.value._tag)
					return options.onMillis(toMillis(_self), toMillis(_that))
				if ("Nanos" === _self.value._tag || "Nanos" === _that.value._tag) {
					const selfNanos =
							"Nanos" === _self.value._tag
								? _self.value.nanos
								: BigInt(Math.round(1e6 * _self.value.millis)),
						thatNanos =
							"Nanos" === _that.value._tag
								? _that.value.nanos
								: BigInt(Math.round(1e6 * _that.value.millis))
					return options.onNanos(selfNanos, thatNanos)
				}
				return options.onMillis(_self.value.millis, _that.value.millis)
			}),
			Duration_greaterThanOrEqualTo = Function_dual(2, (self, that) =>
				matchWith(self, that, {
					onMillis: (self, that) => self >= that,
					onNanos: (self, that) => self >= that,
				}),
			),
			Duration_equals = Function_dual(2, (self, that) =>
				((self, that) =>
					matchWith(self, that, {
						onMillis: (self, that) => self === that,
						onNanos: (self, that) => self === that,
					}))(decode(self), decode(that)),
			),
			Duration_format = self => {
				const duration = decode(self),
					parts = []
				if ("Infinity" === duration.value._tag) return "Infinity"
				const nanos = (self => {
					const _self = decode(self)
					switch (_self.value._tag) {
						case "Infinity":
							throw new Error("Cannot convert infinite duration to nanos")
						case "Nanos":
							return _self.value.nanos
						case "Millis":
							return BigInt(Math.round(1e6 * _self.value.millis))
					}
				})(duration)
				nanos % bigint1e6 && parts.push((nanos % bigint1e6) + "ns")
				const ms = nanos / bigint1e6
				ms % bigint1e3 !== bigint0 && parts.push((ms % bigint1e3) + "ms")
				const sec = ms / bigint1e3
				sec % bigint60 !== bigint0 && parts.push((sec % bigint60) + "s")
				const min = sec / bigint60
				min % bigint60 !== bigint0 && parts.push((min % bigint60) + "m")
				const hr = min / bigint60
				hr % bigint24 !== bigint0 && parts.push((hr % bigint24) + "h")
				const days = hr / bigint24
				days !== bigint0 && parts.push(`${days}d`)
				return parts.reverse().join(" ")
			},
			Either_right = right => {
				const a = Object.create(RightProto)
				a.right = right
				return a
			},
			Either_left = left => {
				const a = Object.create(LeftProto)
				a.left = left
				return a
			},
			Either_isLeft = isLeft,
			Either_isRight = isRight,
			Either_match = Function_dual(2, (self, { onLeft, onRight }) =>
				Either_isLeft(self) ? onLeft(self.left) : onRight(self.right),
			),
			Either_merge = Either_match({
				onLeft: Function_identity,
				onRight: Function_identity,
			}),
			Either_getOrThrowWith = Function_dual(2, (self, onLeft) => {
				if (Either_isRight(self)) return self.right
				throw onLeft(self.left)
			}),
			BUCKET_SIZE = Math.pow(2, 5),
			MASK = BUCKET_SIZE - 1,
			MAX_INDEX_NODE = BUCKET_SIZE / 2,
			MIN_ARRAY_NODE = BUCKET_SIZE / 4
		function hashFragment(shift, h) {
			return (h >>> shift) & MASK
		}
		function toBitmap(x) {
			return 1 << x
		}
		function fromBitmap(bitmap, bit) {
			return (function (x) {
				x =
					((x =
						(858993459 & (x -= (x >> 1) & 1431655765)) +
						((x >> 2) & 858993459)) +
						(x >> 4)) &
					252645135
				return 127 & ((x += x >> 8) + (x >> 16))
			})(bitmap & (bit - 1))
		}
		function arrayUpdate(mutate, at, v, arr) {
			let out = arr
			if (!mutate) {
				const len = arr.length
				out = new Array(len)
				for (let i = 0; i < len; ++i) out[i] = arr[i]
			}
			out[at] = v
			return out
		}
		function arraySpliceOut(mutate, at, arr) {
			const newLen = arr.length - 1
			let i = 0,
				g = 0,
				out = arr
			if (mutate) i = g = at
			else {
				out = new Array(newLen)
				for (; i < at; ) out[g++] = arr[i++]
			}
			++i
			for (; i <= newLen; ) out[g++] = arr[i++]
			mutate && (out.length = newLen)
			return out
		}
		class EmptyNode {
			_tag = "EmptyNode"
			modify(edit, _shift, f, hash, key, size) {
				const v = f(Option_none())
				if (Option_isNone(v)) return new EmptyNode()
				++size.value
				return new LeafNode(edit, hash, key, v)
			}
		}
		function isEmptyNode(a) {
			return Predicate_isTagged(a, "EmptyNode")
		}
		function canEditNode(node, edit) {
			return !isEmptyNode(node) && edit === node.edit
		}
		class LeafNode {
			edit
			hash
			key
			value
			_tag = "LeafNode"
			constructor(edit, hash, key, value) {
				this.edit = edit
				this.hash = hash
				this.key = key
				this.value = value
			}
			modify(edit, shift, f, hash, key, size) {
				if (equals(key, this.key)) {
					const v = f(this.value)
					if (v === this.value) return this
					if (Option_isNone(v)) {
						--size.value
						return new EmptyNode()
					}
					if (canEditNode(this, edit)) {
						this.value = v
						return this
					}
					return new LeafNode(edit, hash, key, v)
				}
				const v = f(Option_none())
				if (Option_isNone(v)) return this
				++size.value
				return mergeLeaves(
					edit,
					shift,
					this.hash,
					this,
					hash,
					new LeafNode(edit, hash, key, v),
				)
			}
		}
		class CollisionNode {
			edit
			hash
			children
			_tag = "CollisionNode"
			constructor(edit, hash, children) {
				this.edit = edit
				this.hash = hash
				this.children = children
			}
			modify(edit, shift, f, hash, key, size) {
				if (hash === this.hash) {
					const canEdit = canEditNode(this, edit),
						list = this.updateCollisionList(
							canEdit,
							edit,
							this.hash,
							this.children,
							f,
							key,
							size,
						)
					return list === this.children
						? this
						: list.length > 1
							? new CollisionNode(edit, this.hash, list)
							: list[0]
				}
				const v = f(Option_none())
				if (Option_isNone(v)) return this
				++size.value
				return mergeLeaves(
					edit,
					shift,
					this.hash,
					this,
					hash,
					new LeafNode(edit, hash, key, v),
				)
			}
			updateCollisionList(mutate, edit, hash, list, f, key, size) {
				const len = list.length
				for (let i = 0; i < len; ++i) {
					const child = list[i]
					if ("key" in child && equals(key, child.key)) {
						const value = child.value,
							newValue = f(value)
						if (newValue === value) return list
						if (Option_isNone(newValue)) {
							--size.value
							return arraySpliceOut(mutate, i, list)
						}
						return arrayUpdate(
							mutate,
							i,
							new LeafNode(edit, hash, key, newValue),
							list,
						)
					}
				}
				const newValue = f(Option_none())
				if (Option_isNone(newValue)) return list
				++size.value
				return arrayUpdate(
					mutate,
					len,
					new LeafNode(edit, hash, key, newValue),
					list,
				)
			}
		}
		class IndexedNode {
			edit
			mask
			children
			_tag = "IndexedNode"
			constructor(edit, mask, children) {
				this.edit = edit
				this.mask = mask
				this.children = children
			}
			modify(edit, shift, f, hash, key, size) {
				const mask = this.mask,
					children = this.children,
					frag = hashFragment(shift, hash),
					bit = toBitmap(frag),
					indx = fromBitmap(mask, bit),
					exists = mask & bit,
					canEdit = canEditNode(this, edit)
				if (!exists) {
					const _newChild = new EmptyNode().modify(
						edit,
						shift + 5,
						f,
						hash,
						key,
						size,
					)
					return _newChild
						? children.length >= MAX_INDEX_NODE
							? (function (edit, frag, child, bitmap, subNodes) {
									const arr = []
									let bit = bitmap,
										count = 0
									for (let i = 0; bit; ++i) {
										1 & bit && (arr[i] = subNodes[count++])
										bit >>>= 1
									}
									arr[frag] = child
									return new ArrayNode(edit, count + 1, arr)
								})(edit, frag, _newChild, mask, children)
							: new IndexedNode(
									edit,
									mask | bit,
									(function (mutate, at, v, arr) {
										const len = arr.length
										if (mutate) {
											let i = len
											for (; i >= at; ) arr[i--] = arr[i]
											arr[at] = v
											return arr
										}
										let i = 0,
											g = 0
										const out = new Array(len + 1)
										for (; i < at; ) out[g++] = arr[i++]
										out[at] = v
										for (; i < len; ) out[++g] = arr[i++]
										return out
									})(canEdit, indx, _newChild, children),
								)
						: this
				}
				const current = children[indx],
					child = current.modify(edit, shift + 5, f, hash, key, size)
				if (current === child) return this
				let newChildren,
					bitmap = mask
				if (isEmptyNode(child)) {
					bitmap &= ~bit
					if (!bitmap) return new EmptyNode()
					if (
						children.length <= 2 &&
						(isEmptyNode((node = children[1 ^ indx])) ||
							"LeafNode" === node._tag ||
							"CollisionNode" === node._tag)
					)
						return children[1 ^ indx]
					newChildren = arraySpliceOut(canEdit, indx, children)
				} else newChildren = arrayUpdate(canEdit, indx, child, children)
				var node
				if (canEdit) {
					this.mask = bitmap
					this.children = newChildren
					return this
				}
				return new IndexedNode(edit, bitmap, newChildren)
			}
		}
		class ArrayNode {
			edit
			size
			children
			_tag = "ArrayNode"
			constructor(edit, size, children) {
				this.edit = edit
				this.size = size
				this.children = children
			}
			modify(edit, shift, f, hash, key, size) {
				let count = this.size
				const children = this.children,
					frag = hashFragment(shift, hash),
					child = children[frag],
					newChild = (child || new EmptyNode()).modify(
						edit,
						shift + 5,
						f,
						hash,
						key,
						size,
					)
				if (child === newChild) return this
				const canEdit = canEditNode(this, edit)
				let newChildren
				if (isEmptyNode(child) && !isEmptyNode(newChild)) {
					++count
					newChildren = arrayUpdate(canEdit, frag, newChild, children)
				} else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
					--count
					if (count <= MIN_ARRAY_NODE)
						return (function (edit, count, removed, elements) {
							const children = new Array(count - 1)
							let g = 0,
								bitmap = 0
							for (let i = 0, len = elements.length; i < len; ++i)
								if (i !== removed) {
									const elem = elements[i]
									if (elem && !isEmptyNode(elem)) {
										children[g++] = elem
										bitmap |= 1 << i
									}
								}
							return new IndexedNode(edit, bitmap, children)
						})(edit, count, frag, children)
					newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children)
				} else newChildren = arrayUpdate(canEdit, frag, newChild, children)
				if (canEdit) {
					this.size = count
					this.children = newChildren
					return this
				}
				return new ArrayNode(edit, count, newChildren)
			}
		}
		function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
			if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1])
			const subH1 = hashFragment(shift, h1),
				subH2 = hashFragment(shift, h2)
			if (subH1 === subH2)
				return child =>
					new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child])
			{
				const children = subH1 < subH2 ? [n1, n2] : [n2, n1]
				return new IndexedNode(
					edit,
					toBitmap(subH1) | toBitmap(subH2),
					children,
				)
			}
		}
		function mergeLeaves(edit, shift, h1, n1, h2, n2) {
			let stack,
				currentShift = shift
			for (;;) {
				const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2)
				if ("function" != typeof res) {
					let final = res
					for (; null != stack; ) {
						final = stack.value(final)
						stack = stack.previous
					}
					return final
				}
				stack = { value: res, previous: stack }
				currentShift += 5
			}
		}
		const HashMapTypeId = Symbol.for("effect/HashMap"),
			HashMapProto = {
				[HashMapTypeId]: HashMapTypeId,
				[Symbol.iterator]() {
					return new HashMapIterator(this, (k, v) => [k, v])
				},
				[symbol]() {
					let hash = Hash_hash("effect/HashMap")
					for (const item of this)
						hash ^= Function_pipe(
							Hash_hash(item[0]),
							combine(Hash_hash(item[1])),
						)
					return cached(this, hash)
				},
				[Equal_symbol](that) {
					if (isHashMap(that)) {
						if (that._size !== this._size) return !1
						for (const item of this) {
							const elem = Function_pipe(
								that,
								getHash(item[0], Hash_hash(item[0])),
							)
							if (Option_isNone(elem)) return !1
							if (!equals(item[1], elem.value)) return !1
						}
						return !0
					}
					return !1
				},
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "HashMap", values: Array.from(this).map(toJSON) }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			makeImpl = (editable, edit, root, size) => {
				const map = Object.create(HashMapProto)
				map._editable = editable
				map._edit = edit
				map._root = root
				map._size = size
				return map
			}
		class HashMapIterator {
			map
			f
			v
			constructor(map, f) {
				this.map = map
				this.f = f
				this.v = visitLazy(this.map._root, this.f, void 0)
			}
			next() {
				if (Option_isNone(this.v)) return { done: !0, value: void 0 }
				const v0 = this.v.value
				this.v = applyCont(v0.cont)
				return { done: !1, value: v0.value }
			}
			[Symbol.iterator]() {
				return new HashMapIterator(this.map, this.f)
			}
		}
		const applyCont = cont =>
				cont
					? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4])
					: Option_none(),
			visitLazy = (node, f, cont = void 0) => {
				switch (node._tag) {
					case "LeafNode":
						return Option_isSome(node.value)
							? Option_some({ value: f(node.key, node.value.value), cont })
							: applyCont(cont)
					case "CollisionNode":
					case "ArrayNode":
					case "IndexedNode": {
						const children = node.children
						return visitLazyChildren(children.length, children, 0, f, cont)
					}
					default:
						return applyCont(cont)
				}
			},
			visitLazyChildren = (len, children, i, f, cont) => {
				for (; i < len; ) {
					const child = children[i++]
					if (child && !isEmptyNode(child))
						return visitLazy(child, f, [len, children, i, f, cont])
				}
				return applyCont(cont)
			},
			hashMap_empty = makeImpl(!1, 0, new EmptyNode(), 0),
			internal_hashMap_empty = () => hashMap_empty,
			isHashMap = u => Predicate_hasProperty(u, HashMapTypeId),
			hashMap_get = Function_dual(2, (self, key) =>
				getHash(self, key, Hash_hash(key)),
			),
			getHash = Function_dual(3, (self, key, hash) => {
				let node = self._root,
					shift = 0
				for (;;)
					switch (node._tag) {
						case "LeafNode":
							return equals(key, node.key) ? node.value : Option_none()
						case "CollisionNode":
							if (hash === node.hash) {
								const children = node.children
								for (let i = 0, len = children.length; i < len; ++i) {
									const child = children[i]
									if ("key" in child && equals(key, child.key))
										return child.value
								}
							}
							return Option_none()
						case "IndexedNode": {
							const bit = toBitmap(hashFragment(shift, hash))
							if (node.mask & bit) {
								node = node.children[fromBitmap(node.mask, bit)]
								shift += 5
								break
							}
							return Option_none()
						}
						case "ArrayNode":
							node = node.children[hashFragment(shift, hash)]
							if (node) {
								shift += 5
								break
							}
							return Option_none()
						default:
							return Option_none()
					}
			}),
			hashMap_has = Function_dual(2, (self, key) =>
				Option_isSome(getHash(self, key, Hash_hash(key))),
			),
			hashMap_set = Function_dual(3, (self, key, value) =>
				modifyAt(self, key, () => Option_some(value)),
			),
			setTree = Function_dual(3, (self, newRoot, newSize) => {
				if (self._editable) {
					self._root = newRoot
					self._size = newSize
					return self
				}
				return newRoot === self._root
					? self
					: makeImpl(self._editable, self._edit, newRoot, newSize)
			}),
			hashMap_keys = self => new HashMapIterator(self, key => key),
			hashMap_size = self => self._size,
			beginMutation = self =>
				makeImpl(!0, self._edit + 1, self._root, self._size),
			modifyAt = Function_dual(3, (self, key, f) =>
				modifyHash(self, key, Hash_hash(key), f),
			),
			modifyHash = Function_dual(4, (self, key, hash, f) => {
				const size = { value: self._size },
					newRoot = self._root.modify(
						self._editable ? self._edit : NaN,
						0,
						f,
						hash,
						key,
						size,
					)
				return Function_pipe(self, setTree(newRoot, size.value))
			}),
			hashMap_remove = Function_dual(2, (self, key) =>
				modifyAt(self, key, Option_none),
			),
			hashMap_map = Function_dual(2, (self, f) =>
				hashMap_reduce(self, internal_hashMap_empty(), (map, value, key) =>
					hashMap_set(map, key, f(value, key)),
				),
			),
			hashMap_forEach = Function_dual(2, (self, f) =>
				hashMap_reduce(self, void 0, (_, value, key) => f(value, key)),
			),
			hashMap_reduce = Function_dual(3, (self, zero, f) => {
				const root = self._root
				if ("LeafNode" === root._tag)
					return Option_isSome(root.value)
						? f(zero, root.value.value, root.key)
						: zero
				if ("EmptyNode" === root._tag) return zero
				const toVisit = [root.children]
				let children
				for (; (children = toVisit.pop()); )
					for (let i = 0, len = children.length; i < len; ) {
						const child = children[i++]
						child &&
							!isEmptyNode(child) &&
							("LeafNode" === child._tag
								? Option_isSome(child.value) &&
									(zero = f(zero, child.value.value, child.key))
								: toVisit.push(child.children))
					}
				return zero
			}),
			HashSetTypeId = Symbol.for("effect/HashSet"),
			HashSetProto = {
				[HashSetTypeId]: HashSetTypeId,
				[Symbol.iterator]() {
					return hashMap_keys(this._keyMap)
				},
				[symbol]() {
					return cached(
						this,
						combine(Hash_hash(this._keyMap))(Hash_hash("effect/HashSet")),
					)
				},
				[Equal_symbol](that) {
					return (
						!!isHashSet(that) &&
						hashMap_size(this._keyMap) === hashMap_size(that._keyMap) &&
						equals(this._keyMap, that._keyMap)
					)
				},
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "HashSet", values: Array.from(this).map(toJSON) }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			hashSet_makeImpl = keyMap => {
				const set = Object.create(HashSetProto)
				set._keyMap = keyMap
				return set
			},
			isHashSet = u => Predicate_hasProperty(u, HashSetTypeId),
			hashSet_empty = hashSet_makeImpl(internal_hashMap_empty()),
			internal_hashSet_empty = () => hashSet_empty,
			hashSet_has = Function_dual(2, (self, value) =>
				hashMap_has(self._keyMap, value),
			),
			hashSet_beginMutation = self =>
				hashSet_makeImpl(beginMutation(self._keyMap)),
			hashSet_endMutation = self => {
				self._keyMap._editable = !1
				return self
			},
			hashSet_mutate = Function_dual(2, (self, f) => {
				const transient = hashSet_beginMutation(self)
				f(transient)
				return hashSet_endMutation(transient)
			}),
			hashSet_add = Function_dual(2, (self, value) =>
				self._keyMap._editable
					? (hashMap_set(value, !0)(self._keyMap), self)
					: hashSet_makeImpl(hashMap_set(value, !0)(self._keyMap)),
			),
			hashSet_remove = Function_dual(2, (self, value) =>
				self._keyMap._editable
					? (hashMap_remove(value)(self._keyMap), self)
					: hashSet_makeImpl(hashMap_remove(value)(self._keyMap)),
			),
			hashSet_difference = Function_dual(2, (self, that) =>
				hashSet_mutate(self, set => {
					for (const value of that) hashSet_remove(set, value)
				}),
			),
			hashSet_union = Function_dual(2, (self, that) =>
				hashSet_mutate(internal_hashSet_empty(), set => {
					hashSet_forEach(self, value => hashSet_add(set, value))
					for (const value of that) hashSet_add(set, value)
				}),
			),
			hashSet_forEach = Function_dual(2, (self, f) =>
				hashMap_forEach(self._keyMap, (_, k) => f(k)),
			),
			hashSet_reduce = Function_dual(3, (self, zero, f) =>
				hashMap_reduce(self._keyMap, zero, (z, _, a) => f(z, a)),
			),
			HashSet_empty = internal_hashSet_empty,
			HashSet_make = (...elements) => {
				const set = hashSet_beginMutation(internal_hashSet_empty())
				for (const value of elements) hashSet_add(set, value)
				return hashSet_endMutation(set)
			},
			HashSet_has = hashSet_has,
			HashSet_size = self => hashMap_size(self._keyMap),
			HashSet_add = hashSet_add,
			HashSet_remove = hashSet_remove,
			HashSet_difference = hashSet_difference,
			HashSet_union = hashSet_union,
			HashSet_reduce = hashSet_reduce,
			MutableRef_TypeId = Symbol.for("effect/MutableRef"),
			MutableRefProto = {
				[MutableRef_TypeId]: MutableRef_TypeId,
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "MutableRef", current: toJSON(this.current) }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			MutableRef_make = value => {
				const ref = Object.create(MutableRefProto)
				ref.current = value
				return ref
			},
			MutableRef_get = self => self.current,
			MutableRef_set = Function_dual(2, (self, value) => {
				self.current = value
				return self
			}),
			FiberIdTypeId = Symbol.for("effect/FiberId"),
			emptyHash = string("effect/FiberId-None")
		class None {
			[FiberIdTypeId] = FiberIdTypeId
			_tag = "None"
			id = -1
			startTimeMillis = -1;
			[symbol]() {
				return emptyHash
			}
			[Equal_symbol](that) {
				return isFiberId(that) && "None" === that._tag
			}
			toString() {
				return format(this.toJSON())
			}
			toJSON() {
				return { _id: "FiberId", _tag: this._tag }
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
		}
		class Runtime {
			id
			startTimeMillis;
			[FiberIdTypeId] = FiberIdTypeId
			_tag = "Runtime"
			constructor(id, startTimeMillis) {
				this.id = id
				this.startTimeMillis = startTimeMillis
			}
			[symbol]() {
				return cached(
					this,
					string(
						`effect/FiberId-${this._tag}-${this.id}-${this.startTimeMillis}`,
					),
				)
			}
			[Equal_symbol](that) {
				return (
					isFiberId(that) &&
					"Runtime" === that._tag &&
					this.id === that.id &&
					this.startTimeMillis === that.startTimeMillis
				)
			}
			toString() {
				return format(this.toJSON())
			}
			toJSON() {
				return {
					_id: "FiberId",
					_tag: this._tag,
					id: this.id,
					startTimeMillis: this.startTimeMillis,
				}
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
		}
		const fiberId_none = new None(),
			isFiberId = self => Predicate_hasProperty(self, FiberIdTypeId),
			ids = self => {
				switch (self._tag) {
					case "None":
						return HashSet_empty()
					case "Runtime":
						return HashSet_make(self.id)
					case "Composite":
						return Function_pipe(ids(self.left), HashSet_union(ids(self.right)))
				}
			},
			_fiberCounter = globalValue(
				Symbol.for("effect/Fiber/Id/_fiberCounter"),
				() => MutableRef_make(0),
			),
			threadName = self =>
				Array.from(ids(self))
					.map(n => `#${n}`)
					.join(","),
			FiberId_none = fiberId_none,
			FiberId_threadName = threadName,
			FiberId_unsafeMake = () => {
				const id = MutableRef_get(_fiberCounter)
				Function_pipe(_fiberCounter, MutableRef_set(id + 1))
				return new Runtime(id, Date.now())
			},
			HashMap_empty = internal_hashMap_empty,
			HashMap_get = hashMap_get,
			HashMap_set = hashMap_set,
			HashMap_keys = hashMap_keys,
			HashMap_size = hashMap_size,
			HashMap_modifyAt = modifyAt,
			HashMap_map = hashMap_map,
			HashMap_reduce = hashMap_reduce,
			List_TypeId = Symbol.for("effect/List"),
			List_toArray = self => Array_fromIterable(self),
			List_getEquivalence = isEquivalent =>
				Equivalence_mapInput(Array_getEquivalence(isEquivalent), List_toArray),
			List_equivalence = List_getEquivalence(equals),
			ConsProto = {
				[List_TypeId]: List_TypeId,
				_tag: "Cons",
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return {
						_id: "List",
						_tag: "Cons",
						values: List_toArray(this).map(toJSON),
					}
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				[Equal_symbol](that) {
					return (
						isList(that) &&
						this._tag === that._tag &&
						List_equivalence(this, that)
					)
				},
				[symbol]() {
					return cached(this, array(List_toArray(this)))
				},
				[Symbol.iterator]() {
					let done = !1,
						self = this
					return {
						next() {
							if (done) return this.return()
							if ("Nil" === self._tag) {
								done = !0
								return this.return()
							}
							const value = self.head
							self = self.tail
							return { done, value }
						},
						return(value) {
							done || (done = !0)
							return { done: !0, value }
						},
					}
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			makeCons = (head, tail) => {
				const cons = Object.create(ConsProto)
				cons.head = head
				cons.tail = tail
				return cons
			},
			NilHash = string("Nil"),
			NilProto = {
				[List_TypeId]: List_TypeId,
				_tag: "Nil",
				toString() {
					return format(this.toJSON())
				},
				toJSON: () => ({ _id: "List", _tag: "Nil" }),
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				[symbol]: () => NilHash,
				[Equal_symbol](that) {
					return isList(that) && this._tag === that._tag
				},
				[Symbol.iterator]: () => ({
					next: () => ({ done: !0, value: void 0 }),
				}),
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			_Nil = Object.create(NilProto),
			isList = u => Predicate_hasProperty(u, List_TypeId),
			isNil = self => "Nil" === self._tag,
			isCons = self => "Cons" === self._tag,
			cons = (head, tail) => makeCons(head, tail),
			List_empty = () => _Nil,
			List_of = value => makeCons(value, _Nil),
			List_appendAll = Function_dual(2, (self, that) =>
				List_prependAll(that, self),
			),
			List_prepend = Function_dual(2, (self, element) => cons(element, self)),
			List_prependAll = Function_dual(2, (self, prefix) => {
				if (isNil(self)) return prefix
				if (isNil(prefix)) return self
				{
					const result = makeCons(prefix.head, self)
					let curr = result,
						that = prefix.tail
					for (; !isNil(that); ) {
						const temp = makeCons(that.head, self)
						curr.tail = temp
						curr = temp
						that = that.tail
					}
					return result
				}
			}),
			List_reduce = Function_dual(3, (self, zero, f) => {
				let acc = zero,
					these = self
				for (; !isNil(these); ) {
					acc = f(acc, these.head)
					these = these.tail
				}
				return acc
			}),
			List_reverse = self => {
				let result = List_empty(),
					these = self
				for (; !isNil(these); ) {
					result = List_prepend(result, these.head)
					these = these.tail
				}
				return result
			},
			Structural =
				(Array.prototype,
				(function () {
					function Structural(args) {
						args && Object.assign(this, args)
					}
					Structural.prototype = effectable_StructuralPrototype
					return Structural
				})())
		Structural.prototype
		const ContextPatchTypeId = Symbol.for("effect/DifferContextPatch")
		function contextPatch_variance(a) {
			return a
		}
		const contextPatch_PatchProto = {
				...Structural.prototype,
				[ContextPatchTypeId]: {
					_Value: contextPatch_variance,
					_Patch: contextPatch_variance,
				},
			},
			contextPatch_EmptyProto = Object.assign(
				Object.create(contextPatch_PatchProto),
				{ _tag: "Empty" },
			),
			contextPatch_empty = Object.create(contextPatch_EmptyProto),
			differ_contextPatch_empty = () => contextPatch_empty,
			contextPatch_AndThenProto = Object.assign(
				Object.create(contextPatch_PatchProto),
				{ _tag: "AndThen" },
			),
			AddServiceProto = Object.assign(Object.create(contextPatch_PatchProto), {
				_tag: "AddService",
			}),
			makeAddService = (key, service) => {
				const o = Object.create(AddServiceProto)
				o.key = key
				o.service = service
				return o
			},
			RemoveServiceProto = Object.assign(
				Object.create(contextPatch_PatchProto),
				{ _tag: "RemoveService" },
			),
			makeRemoveService = key => {
				const o = Object.create(RemoveServiceProto)
				o.key = key
				return o
			},
			UpdateServiceProto = Object.assign(
				Object.create(contextPatch_PatchProto),
				{ _tag: "UpdateService" },
			),
			makeUpdateService = (key, update) => {
				const o = Object.create(UpdateServiceProto)
				o.key = key
				o.update = update
				return o
			},
			contextPatch_combine = Function_dual(2, (self, that) =>
				((first, second) => {
					const o = Object.create(contextPatch_AndThenProto)
					o.first = first
					o.second = second
					return o
				})(self, that),
			),
			contextPatch_patch = Function_dual(2, (self, context) => {
				if ("Empty" === self._tag) return context
				let wasServiceUpdated = !1,
					patches = Chunk_of(self)
				const updatedContext = new Map(context.unsafeMap)
				for (; isNonEmpty(patches); ) {
					const head = Chunk_headNonEmpty(patches),
						tail = Chunk_tailNonEmpty(patches)
					switch (head._tag) {
						case "Empty":
							patches = tail
							break
						case "AddService":
							updatedContext.set(head.key, head.service)
							patches = tail
							break
						case "AndThen":
							patches = Chunk_prepend(
								Chunk_prepend(tail, head.second),
								head.first,
							)
							break
						case "RemoveService":
							updatedContext.delete(head.key)
							patches = tail
							break
						case "UpdateService":
							updatedContext.set(
								head.key,
								head.update(updatedContext.get(head.key)),
							)
							wasServiceUpdated = !0
							patches = tail
					}
				}
				if (!wasServiceUpdated) return makeContext(updatedContext)
				const map = new Map()
				for (const [tag] of context.unsafeMap)
					if (updatedContext.has(tag)) {
						map.set(tag, updatedContext.get(tag))
						updatedContext.delete(tag)
					}
				for (const [tag, s] of updatedContext) map.set(tag, s)
				return makeContext(map)
			})
		Structural.prototype
		const HashSetPatchTypeId = Symbol.for("effect/DifferHashSetPatch")
		function hashSetPatch_variance(a) {
			return a
		}
		const hashSetPatch_PatchProto = {
				...Structural.prototype,
				[HashSetPatchTypeId]: {
					_Value: hashSetPatch_variance,
					_Key: hashSetPatch_variance,
					_Patch: hashSetPatch_variance,
				},
			},
			hashSetPatch_EmptyProto = Object.assign(
				Object.create(hashSetPatch_PatchProto),
				{ _tag: "Empty" },
			),
			hashSetPatch_empty = Object.create(hashSetPatch_EmptyProto),
			differ_hashSetPatch_empty = () => hashSetPatch_empty,
			hashSetPatch_AndThenProto = Object.assign(
				Object.create(hashSetPatch_PatchProto),
				{ _tag: "AndThen" },
			),
			hashSetPatch_AddProto = Object.assign(
				Object.create(hashSetPatch_PatchProto),
				{ _tag: "Add" },
			),
			hashSetPatch_makeAdd = value => {
				const o = Object.create(hashSetPatch_AddProto)
				o.value = value
				return o
			},
			hashSetPatch_RemoveProto = Object.assign(
				Object.create(hashSetPatch_PatchProto),
				{ _tag: "Remove" },
			),
			hashSetPatch_combine = Function_dual(2, (self, that) =>
				((first, second) => {
					const o = Object.create(hashSetPatch_AndThenProto)
					o.first = first
					o.second = second
					return o
				})(self, that),
			),
			hashSetPatch_patch = Function_dual(2, (self, oldValue) => {
				if ("Empty" === self._tag) return oldValue
				let set = oldValue,
					patches = Chunk_of(self)
				for (; isNonEmpty(patches); ) {
					const head = Chunk_headNonEmpty(patches),
						tail = Chunk_tailNonEmpty(patches)
					switch (head._tag) {
						case "Empty":
							patches = tail
							break
						case "AndThen":
							patches = Chunk_prepend(head.first)(
								Chunk_prepend(head.second)(tail),
							)
							break
						case "Add":
							set = HashSet_add(head.value)(set)
							patches = tail
							break
						case "Remove":
							set = HashSet_remove(head.value)(set)
							patches = tail
					}
				}
				return set
			})
		Structural.prototype
		const ReadonlyArrayPatchTypeId = Symbol.for(
			"effect/DifferReadonlyArrayPatch",
		)
		function readonlyArrayPatch_variance(a) {
			return a
		}
		const readonlyArrayPatch_PatchProto = {
				...Structural.prototype,
				[ReadonlyArrayPatchTypeId]: {
					_Value: readonlyArrayPatch_variance,
					_Patch: readonlyArrayPatch_variance,
				},
			},
			readonlyArrayPatch_EmptyProto = Object.assign(
				Object.create(readonlyArrayPatch_PatchProto),
				{ _tag: "Empty" },
			),
			readonlyArrayPatch_empty = Object.create(readonlyArrayPatch_EmptyProto),
			differ_readonlyArrayPatch_empty = () => readonlyArrayPatch_empty,
			readonlyArrayPatch_AndThenProto = Object.assign(
				Object.create(readonlyArrayPatch_PatchProto),
				{ _tag: "AndThen" },
			),
			readonlyArrayPatch_AppendProto = Object.assign(
				Object.create(readonlyArrayPatch_PatchProto),
				{ _tag: "Append" },
			),
			readonlyArrayPatch_SliceProto = Object.assign(
				Object.create(readonlyArrayPatch_PatchProto),
				{ _tag: "Slice" },
			),
			readonlyArrayPatch_UpdateProto = Object.assign(
				Object.create(readonlyArrayPatch_PatchProto),
				{ _tag: "Update" },
			),
			readonlyArrayPatch_makeUpdate = (index, patch) => {
				const o = Object.create(readonlyArrayPatch_UpdateProto)
				o.index = index
				o.patch = patch
				return o
			},
			readonlyArrayPatch_combine = Function_dual(2, (self, that) =>
				((first, second) => {
					const o = Object.create(readonlyArrayPatch_AndThenProto)
					o.first = first
					o.second = second
					return o
				})(self, that),
			),
			readonlyArrayPatch_patch = Function_dual(3, (self, oldValue, differ) => {
				if ("Empty" === self._tag) return oldValue
				let readonlyArray = oldValue.slice(),
					patches = Array_of(self)
				for (; Array_isNonEmptyArray(patches); ) {
					const head = headNonEmpty(patches),
						tail = tailNonEmpty(patches)
					switch (head._tag) {
						case "Empty":
							patches = tail
							break
						case "AndThen":
							tail.unshift(head.first, head.second)
							patches = tail
							break
						case "Append":
							for (const value of head.values) readonlyArray.push(value)
							patches = tail
							break
						case "Slice":
							readonlyArray = readonlyArray.slice(head.from, head.until)
							patches = tail
							break
						case "Update":
							readonlyArray[head.index] = differ.patch(
								head.patch,
								readonlyArray[head.index],
							)
							patches = tail
					}
				}
				return readonlyArray
			}),
			DifferProto = {
				[Symbol.for("effect/Differ")]: {
					_P: Function_identity,
					_V: Function_identity,
				},
			},
			differ_make = params => {
				const differ = Object.create(DifferProto)
				differ.empty = params.empty
				differ.diff = params.diff
				differ.combine = params.combine
				differ.patch = params.patch
				return differ
			},
			differ_update = () => updateWith((_, a) => a),
			updateWith = f =>
				differ_make({
					empty: Function_identity,
					combine: (first, second) =>
						first === Function_identity
							? second
							: second === Function_identity
								? first
								: a => second(first(a)),
					diff: (oldValue, newValue) =>
						equals(oldValue, newValue) ? Function_identity : constant(newValue),
					patch: (patch, oldValue) => f(oldValue, patch(oldValue)),
				}),
			active = patch => 255 & patch,
			enabled = patch => (patch >> 8) & 255,
			runtimeFlagsPatch_make = (active, enabled) =>
				(255 & active) + ((enabled & active & 255) << 8),
			runtimeFlagsPatch_empty = runtimeFlagsPatch_make(0, 0),
			exclude = Function_dual(2, (self, flag) =>
				runtimeFlagsPatch_make(active(self) & ~flag, enabled(self)),
			),
			runtimeFlagsPatch_andThen = Function_dual(2, (self, that) => self | that),
			cooperativeYielding = self => runtimeFlags_isEnabled(self, 32),
			runtimeFlags_enable = Function_dual(2, (self, flag) => self | flag),
			interruptible = self => interruption(self) && !windDown(self),
			interruption = self => runtimeFlags_isEnabled(self, 1),
			runtimeFlags_isEnabled = Function_dual(
				2,
				(self, flag) => 0 != (self & flag),
			),
			runtimeFlags_make = (...flags) => flags.reduce((a, b) => a | b, 0),
			runtimeFlags_none = runtimeFlags_make(0),
			runtimeMetrics = self => runtimeFlags_isEnabled(self, 4),
			windDown = self => runtimeFlags_isEnabled(self, 16),
			runtimeFlags_diff = Function_dual(2, (self, that) =>
				runtimeFlagsPatch_make(self ^ that, that),
			),
			runtimeFlags_patch = Function_dual(
				2,
				(self, patch) =>
					(self & (((~active(patch) >>> 0) & 255) | enabled(patch))) |
					(active(patch) & enabled(patch)),
			),
			differ = differ_make({
				empty: runtimeFlagsPatch_empty,
				diff: (oldValue, newValue) => runtimeFlags_diff(oldValue, newValue),
				combine: (first, second) => runtimeFlagsPatch_andThen(second)(first),
				patch: (_patch, oldValue) => runtimeFlags_patch(oldValue, _patch),
			}),
			RuntimeFlagsPatch_disable = flag => runtimeFlagsPatch_make(flag, 0),
			RuntimeFlagsPatch_exclude = exclude,
			CauseTypeId = Symbol.for("effect/Cause"),
			proto = {
				[CauseTypeId]: { _E: _ => _ },
				[symbol]() {
					return Function_pipe(
						Hash_hash("effect/Cause"),
						combine(Hash_hash(flattenCause(this))),
						cached(this),
					)
				},
				[Equal_symbol](that) {
					return isCause(that) && causeEquals(this, that)
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
				toJSON() {
					switch (this._tag) {
						case "Empty":
							return { _id: "Cause", _tag: this._tag }
						case "Die":
							return {
								_id: "Cause",
								_tag: this._tag,
								defect: toJSON(this.defect),
							}
						case "Interrupt":
							return {
								_id: "Cause",
								_tag: this._tag,
								fiberId: this.fiberId.toJSON(),
							}
						case "Fail":
							return {
								_id: "Cause",
								_tag: this._tag,
								failure: toJSON(this.error),
							}
						case "Sequential":
						case "Parallel":
							return {
								_id: "Cause",
								_tag: this._tag,
								left: toJSON(this.left),
								right: toJSON(this.right),
							}
					}
				},
				toString() {
					return pretty(this)
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
			},
			cause_empty = (() => {
				const o = Object.create(proto)
				o._tag = "Empty"
				return o
			})(),
			fail = error => {
				const o = Object.create(proto)
				o._tag = "Fail"
				o.error = error
				return o
			},
			die = defect => {
				const o = Object.create(proto)
				o._tag = "Die"
				o.defect = defect
				return o
			},
			interrupt = fiberId => {
				const o = Object.create(proto)
				o._tag = "Interrupt"
				o.fiberId = fiberId
				return o
			},
			parallel = (left, right) => {
				const o = Object.create(proto)
				o._tag = "Parallel"
				o.left = left
				o.right = right
				return o
			},
			sequential = (left, right) => {
				const o = Object.create(proto)
				o._tag = "Sequential"
				o.left = left
				o.right = right
				return o
			},
			isCause = u => Predicate_hasProperty(u, CauseTypeId),
			isInterruptedOnly = self =>
				reduceWithContext(void 0, IsInterruptedOnlyCauseReducer)(self),
			cause_defects = self =>
				Chunk_reverse(
					cause_reduce(self, esm_Chunk_empty(), (list, cause) =>
						"Die" === cause._tag
							? Option_some(Function_pipe(list, Chunk_prepend(cause.defect)))
							: Option_none(),
					),
				),
			failureOrCause = self => {
				const option = (self =>
					find(self, cause =>
						"Fail" === cause._tag ? Option_some(cause.error) : Option_none(),
					))(self)
				switch (option._tag) {
					case "None":
						return Either_right(self)
					case "Some":
						return Either_left(option.value)
				}
			},
			stripFailures = self =>
				cause_match(self, {
					onEmpty: cause_empty,
					onFail: () => cause_empty,
					onDie: defect => die(defect),
					onInterrupt: fiberId => interrupt(fiberId),
					onSequential: sequential,
					onParallel: parallel,
				}),
			causeEquals = (left, right) => {
				let leftStack = Chunk_of(left),
					rightStack = Chunk_of(right)
				for (; isNonEmpty(leftStack) && isNonEmpty(rightStack); ) {
					const [leftParallel, leftSequential] = Function_pipe(
							Chunk_headNonEmpty(leftStack),
							cause_reduce(
								[HashSet_empty(), esm_Chunk_empty()],
								([parallel, sequential], cause) => {
									const [par, seq] = evaluateCause(cause)
									return Option_some([
										Function_pipe(parallel, HashSet_union(par)),
										Function_pipe(sequential, Chunk_appendAll(seq)),
									])
								},
							),
						),
						[rightParallel, rightSequential] = Function_pipe(
							Chunk_headNonEmpty(rightStack),
							cause_reduce(
								[HashSet_empty(), esm_Chunk_empty()],
								([parallel, sequential], cause) => {
									const [par, seq] = evaluateCause(cause)
									return Option_some([
										Function_pipe(parallel, HashSet_union(par)),
										Function_pipe(sequential, Chunk_appendAll(seq)),
									])
								},
							),
						)
					if (!equals(leftParallel, rightParallel)) return !1
					leftStack = leftSequential
					rightStack = rightSequential
				}
				return !0
			},
			flattenCause = cause =>
				flattenCauseLoop(Chunk_of(cause), esm_Chunk_empty()),
			flattenCauseLoop = (causes, flattened) => {
				for (;;) {
					const [parallel, sequential] = Function_pipe(
							causes,
							Array_reduce(
								[HashSet_empty(), esm_Chunk_empty()],
								([parallel, sequential], cause) => {
									const [par, seq] = evaluateCause(cause)
									return [
										Function_pipe(parallel, HashSet_union(par)),
										Function_pipe(sequential, Chunk_appendAll(seq)),
									]
								},
							),
						),
						updated =
							HashSet_size(parallel) > 0
								? Function_pipe(flattened, Chunk_prepend(parallel))
								: flattened
					if (Chunk_isEmpty(sequential)) return Chunk_reverse(updated)
					causes = sequential
					flattened = updated
				}
				throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"))
			},
			find = Function_dual(2, (self, pf) => {
				const stack = [self]
				for (; stack.length > 0; ) {
					const item = stack.pop(),
						option = pf(item)
					switch (option._tag) {
						case "None":
							switch (item._tag) {
								case "Sequential":
								case "Parallel":
									stack.push(item.right)
									stack.push(item.left)
							}
							break
						case "Some":
							return option
					}
				}
				return Option_none()
			}),
			evaluateCause = self => {
				let cause = self
				const stack = []
				let _parallel = HashSet_empty(),
					_sequential = esm_Chunk_empty()
				for (; void 0 !== cause; )
					switch (cause._tag) {
						case "Empty":
							if (0 === stack.length) return [_parallel, _sequential]
							cause = stack.pop()
							break
						case "Fail":
							_parallel = HashSet_add(
								_parallel,
								Chunk_make(cause._tag, cause.error),
							)
							if (0 === stack.length) return [_parallel, _sequential]
							cause = stack.pop()
							break
						case "Die":
							_parallel = HashSet_add(
								_parallel,
								Chunk_make(cause._tag, cause.defect),
							)
							if (0 === stack.length) return [_parallel, _sequential]
							cause = stack.pop()
							break
						case "Interrupt":
							_parallel = HashSet_add(
								_parallel,
								Chunk_make(cause._tag, cause.fiberId),
							)
							if (0 === stack.length) return [_parallel, _sequential]
							cause = stack.pop()
							break
						case "Sequential":
							switch (cause.left._tag) {
								case "Empty":
									cause = cause.right
									break
								case "Sequential":
									cause = sequential(
										cause.left.left,
										sequential(cause.left.right, cause.right),
									)
									break
								case "Parallel":
									cause = parallel(
										sequential(cause.left.left, cause.right),
										sequential(cause.left.right, cause.right),
									)
									break
								default:
									_sequential = Chunk_prepend(_sequential, cause.right)
									cause = cause.left
							}
							break
						case "Parallel":
							stack.push(cause.right)
							cause = cause.left
					}
				throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"))
			},
			IsInterruptedOnlyCauseReducer = {
				emptyCase: Function_constTrue,
				failCase: constFalse,
				dieCase: constFalse,
				interruptCase: Function_constTrue,
				sequentialCase: (_, left, right) => left && right,
				parallelCase: (_, left, right) => left && right,
			},
			cause_match = Function_dual(
				2,
				(
					self,
					{ onDie, onEmpty, onFail, onInterrupt, onParallel, onSequential },
				) =>
					reduceWithContext(self, void 0, {
						emptyCase: () => onEmpty,
						failCase: (_, error) => onFail(error),
						dieCase: (_, defect) => onDie(defect),
						interruptCase: (_, fiberId) => onInterrupt(fiberId),
						sequentialCase: (_, left, right) => onSequential(left, right),
						parallelCase: (_, left, right) => onParallel(left, right),
					}),
			),
			cause_reduce = Function_dual(3, (self, zero, pf) => {
				let accumulator = zero,
					cause = self
				const causes = []
				for (; void 0 !== cause; ) {
					const option = pf(accumulator, cause)
					accumulator = Option_isSome(option) ? option.value : accumulator
					switch (cause._tag) {
						case "Sequential":
						case "Parallel":
							causes.push(cause.right)
							cause = cause.left
							break
						default:
							cause = void 0
					}
					void 0 === cause && causes.length > 0 && (cause = causes.pop())
				}
				return accumulator
			}),
			reduceWithContext = Function_dual(3, (self, context, reducer) => {
				const input = [self],
					output = []
				for (; input.length > 0; ) {
					const cause = input.pop()
					switch (cause._tag) {
						case "Empty":
							output.push(Either_right(reducer.emptyCase(context)))
							break
						case "Fail":
							output.push(Either_right(reducer.failCase(context, cause.error)))
							break
						case "Die":
							output.push(Either_right(reducer.dieCase(context, cause.defect)))
							break
						case "Interrupt":
							output.push(
								Either_right(reducer.interruptCase(context, cause.fiberId)),
							)
							break
						case "Sequential":
							input.push(cause.right)
							input.push(cause.left)
							output.push(Either_left({ _tag: "SequentialCase" }))
							break
						case "Parallel":
							input.push(cause.right)
							input.push(cause.left)
							output.push(Either_left({ _tag: "ParallelCase" }))
					}
				}
				const accumulator = []
				for (; output.length > 0; ) {
					const either = output.pop()
					switch (either._tag) {
						case "Left":
							switch (either.left._tag) {
								case "SequentialCase": {
									const left = accumulator.pop(),
										right = accumulator.pop(),
										value = reducer.sequentialCase(context, left, right)
									accumulator.push(value)
									break
								}
								case "ParallelCase": {
									const left = accumulator.pop(),
										right = accumulator.pop(),
										value = reducer.parallelCase(context, left, right)
									accumulator.push(value)
									break
								}
							}
							break
						case "Right":
							accumulator.push(either.right)
					}
				}
				if (0 === accumulator.length)
					throw new Error(
						"BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues",
					)
				return accumulator.pop()
			}),
			pretty = (cause, options) =>
				isInterruptedOnly(cause)
					? "All fibers interrupted without errors."
					: cause_prettyErrors(cause)
							.map(function (e) {
								return !0 !== options?.renderErrorCause || void 0 === e.cause
									? e.stack
									: `${e.stack} {\n${renderErrorCause(e.cause, "  ")}\n}`
							})
							.join("\n"),
			renderErrorCause = (cause, prefix) => {
				const lines = cause.stack.split("\n")
				let stack = `${prefix}[cause]: ${lines[0]}`
				for (let i = 1, len = lines.length; i < len; i++)
					stack += `\n${prefix}${lines[i]}`
				cause.cause &&
					(stack += ` {\n${renderErrorCause(cause.cause, `${prefix}  `)}\n${prefix}}`)
				return stack
			}
		class PrettyError extends globalThis.Error {
			span = void 0
			constructor(originalError) {
				const originalErrorIsObject =
						"object" == typeof originalError && null !== originalError,
					prevLimit = Error.stackTraceLimit
				Error.stackTraceLimit = 1
				super(
					prettyErrorMessage(originalError),
					originalErrorIsObject &&
						"cause" in originalError &&
						void 0 !== originalError.cause
						? { cause: new PrettyError(originalError.cause) }
						: void 0,
				)
				"" === this.message && (this.message = "An error has occurred")
				Error.stackTraceLimit = prevLimit
				this.name =
					originalError instanceof Error ? originalError.name : "Error"
				if (originalErrorIsObject) {
					spanSymbol in originalError && (this.span = originalError[spanSymbol])
					Object.keys(originalError).forEach(key => {
						key in this || (this[key] = originalError[key])
					})
				}
				this.stack = prettyErrorStack(
					`${this.name}: ${this.message}`,
					originalError instanceof Error && originalError.stack
						? originalError.stack
						: "",
					this.span,
				)
			}
		}
		const prettyErrorMessage = u => {
				if ("string" == typeof u) return u
				if ("object" == typeof u && null !== u && u instanceof Error)
					return u.message
				try {
					if (
						Predicate_hasProperty(u, "toString") &&
						Predicate_isFunction(u.toString) &&
						u.toString !== Object.prototype.toString &&
						u.toString !== globalThis.Array.prototype.toString
					)
						return u.toString()
				} catch {}
				return JSON.stringify(u)
			},
			locationRegex = /\((.*)\)/,
			spanToTrace = globalValue(
				"effect/Tracer/spanToTrace",
				() => new WeakMap(),
			),
			prettyErrorStack = (message, stack, span) => {
				const out = [message],
					lines = stack.startsWith(message)
						? stack.slice(message.length).split("\n")
						: stack.split("\n")
				for (
					let i = 1;
					i < lines.length && !lines[i].includes("Generator.next");
					i++
				) {
					if (lines[i].includes("effect_internal_function")) {
						out.pop()
						break
					}
					out.push(
						lines[i]
							.replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1")
							.replace(/EffectPrimitive\.\w+/, "<anonymous>"),
					)
				}
				if (span) {
					let current = span,
						i = 0
					for (; current && "Span" === current._tag && i < 10; ) {
						const stackFn = spanToTrace.get(current)
						if ("function" == typeof stackFn) {
							const stack = stackFn()
							if ("string" == typeof stack) {
								const locationMatch = stack.match(locationRegex),
									location = locationMatch
										? locationMatch[1]
										: stack.replace(/^at /, "")
								out.push(`    at ${current.name} (${location})`)
							} else out.push(`    at ${current.name}`)
						} else out.push(`    at ${current.name}`)
						current = getOrUndefined(current.parent)
						i++
					}
				}
				return out.join("\n")
			},
			spanSymbol = Symbol.for("effect/SpanAnnotation"),
			cause_prettyErrors = cause =>
				reduceWithContext(cause, void 0, {
					emptyCase: () => [],
					dieCase: (_, unknownError) => [new PrettyError(unknownError)],
					failCase: (_, error) => [new PrettyError(error)],
					interruptCase: () => [],
					parallelCase: (_, l, r) => [...l, ...r],
					sequentialCase: (_, l, r) => [...l, ...r],
				}),
			DeferredTypeId = Symbol.for("effect/Deferred"),
			deferredVariance = { _E: _ => _, _A: _ => _ },
			done = effect => ({ _tag: "Done", effect })
		class singleShotGen_SingleShotGen {
			self
			called = !1
			constructor(self) {
				this.self = self
			}
			next(a) {
				return this.called
					? { value: a, done: !0 }
					: ((this.called = !0), { value: this.self, done: !1 })
			}
			return(a) {
				return { value: a, done: !0 }
			}
			throw(e) {
				throw e
			}
			[Symbol.iterator]() {
				return new singleShotGen_SingleShotGen(this.self)
			}
		}
		const TracerTypeId = Symbol.for("effect/Tracer"),
			tracer_make = options => ({ [TracerTypeId]: TracerTypeId, ...options }),
			tracerTag = GenericTag("effect/Tracer"),
			spanTag = GenericTag("effect/ParentSpan"),
			randomHexString = (function () {
				return function (length) {
					let result = ""
					for (let i = 0; i < length; i++)
						result += "abcdef0123456789".charAt(Math.floor(16 * Math.random()))
					return result
				}
			})()
		class NativeSpan {
			name
			parent
			context
			links
			startTime
			kind
			_tag = "Span"
			spanId
			traceId = "native"
			sampled = !0
			status
			attributes
			events = []
			constructor(name, parent, context, links, startTime, kind) {
				this.name = name
				this.parent = parent
				this.context = context
				this.links = links
				this.startTime = startTime
				this.kind = kind
				this.status = { _tag: "Started", startTime }
				this.attributes = new Map()
				this.traceId =
					"Some" === parent._tag ? parent.value.traceId : randomHexString(32)
				this.spanId = randomHexString(16)
			}
			end(endTime, exit) {
				this.status = {
					_tag: "Ended",
					endTime,
					exit,
					startTime: this.status.startTime,
				}
			}
			attribute(key, value) {
				this.attributes.set(key, value)
			}
			event(name, startTime, attributes) {
				this.events.push([name, startTime, attributes ?? {}])
			}
		}
		const nativeTracer = tracer_make({
				span: (name, parent, context, links, startTime, kind) =>
					new NativeSpan(name, parent, context, links, startTime, kind),
				context: f => f(),
			}),
			EffectErrorTypeId = Symbol.for("effect/EffectError"),
			isEffectError = u => Predicate_hasProperty(u, EffectErrorTypeId),
			blocked = (blockedRequests, _continue) => {
				const effect = new EffectPrimitive("Blocked")
				effect.effect_instruction_i0 = blockedRequests
				effect.effect_instruction_i1 = _continue
				return effect
			},
			core_EffectTypeId = Symbol.for("effect/Effect")
		class RevertFlags {
			patch
			op
			_op = "RevertFlags"
			constructor(patch, op) {
				this.patch = patch
				this.op = op
			}
		}
		class EffectPrimitive {
			_op
			effect_instruction_i0 = void 0
			effect_instruction_i1 = void 0
			effect_instruction_i2 = void 0
			trace = void 0;
			[core_EffectTypeId] = effectVariance
			constructor(_op) {
				this._op = _op
			}
			[Equal_symbol](that) {
				return this === that
			}
			[symbol]() {
				return cached(this, random(this))
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
			toJSON() {
				return {
					_id: "Effect",
					_op: this._op,
					effect_instruction_i0: toJSON(this.effect_instruction_i0),
					effect_instruction_i1: toJSON(this.effect_instruction_i1),
					effect_instruction_i2: toJSON(this.effect_instruction_i2),
				}
			}
			toString() {
				return format(this.toJSON())
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
			[Symbol.iterator]() {
				return new singleShotGen_SingleShotGen(new YieldWrap(this))
			}
		}
		class EffectPrimitiveFailure {
			_op
			effect_instruction_i0 = void 0
			effect_instruction_i1 = void 0
			effect_instruction_i2 = void 0
			trace = void 0;
			[core_EffectTypeId] = effectVariance
			constructor(_op) {
				this._op = _op
				this._tag = _op
			}
			[Equal_symbol](that) {
				return (
					exitIsExit(that) &&
					"Failure" === that._op &&
					equals(this.effect_instruction_i0, that.effect_instruction_i0)
				)
			}
			[symbol]() {
				return Function_pipe(
					string(this._tag),
					combine(Hash_hash(this.effect_instruction_i0)),
					cached(this),
				)
			}
			get cause() {
				return this.effect_instruction_i0
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
			toJSON() {
				return { _id: "Exit", _tag: this._op, cause: this.cause.toJSON() }
			}
			toString() {
				return format(this.toJSON())
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
			[Symbol.iterator]() {
				return new singleShotGen_SingleShotGen(new YieldWrap(this))
			}
		}
		class EffectPrimitiveSuccess {
			_op
			effect_instruction_i0 = void 0
			effect_instruction_i1 = void 0
			effect_instruction_i2 = void 0
			trace = void 0;
			[core_EffectTypeId] = effectVariance
			constructor(_op) {
				this._op = _op
				this._tag = _op
			}
			[Equal_symbol](that) {
				return (
					exitIsExit(that) &&
					"Success" === that._op &&
					equals(this.effect_instruction_i0, that.effect_instruction_i0)
				)
			}
			[symbol]() {
				return Function_pipe(
					string(this._tag),
					combine(Hash_hash(this.effect_instruction_i0)),
					cached(this),
				)
			}
			get value() {
				return this.effect_instruction_i0
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
			toJSON() {
				return { _id: "Exit", _tag: this._op, value: toJSON(this.value) }
			}
			toString() {
				return format(this.toJSON())
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
			[Symbol.iterator]() {
				return new singleShotGen_SingleShotGen(new YieldWrap(this))
			}
		}
		const isEffect = u => Predicate_hasProperty(u, core_EffectTypeId),
			withFiberRuntime = withRuntime => {
				const effect = new EffectPrimitive("WithRuntime")
				effect.effect_instruction_i0 = withRuntime
				return effect
			},
			acquireUseRelease = Function_dual(3, (acquire, use, release) =>
				uninterruptibleMask(restore =>
					core_flatMap(acquire, a =>
						core_flatMap(core_exit(suspend(() => restore(use(a)))), exit =>
							suspend(() => release(a, exit)).pipe(
								matchCauseEffect({
									onFailure: cause => {
										switch (exit._tag) {
											case "Failure":
												return failCause(
													parallel(exit.effect_instruction_i0, cause),
												)
											case "Success":
												return failCause(cause)
										}
									},
									onSuccess: () => exit,
								}),
							),
						),
					),
				),
			),
			core_as = Function_dual(2, (self, value) =>
				core_flatMap(self, () => succeed(value)),
			),
			core_asVoid = self => core_as(self, void 0),
			custom = function () {
				const wrapper = new EffectPrimitive("Commit")
				switch (arguments.length) {
					case 2:
						wrapper.effect_instruction_i0 = arguments[0]
						wrapper.commit = arguments[1]
						break
					case 3:
						wrapper.effect_instruction_i0 = arguments[0]
						wrapper.effect_instruction_i1 = arguments[1]
						wrapper.commit = arguments[2]
						break
					case 4:
						wrapper.effect_instruction_i0 = arguments[0]
						wrapper.effect_instruction_i1 = arguments[1]
						wrapper.effect_instruction_i2 = arguments[2]
						wrapper.commit = arguments[3]
						break
					default:
						throw new Error(
							getBugErrorMessage("you're not supposed to end up here"),
						)
				}
				return wrapper
			},
			core_async = (register, blockingOn = FiberId_none) =>
				custom(register, function () {
					let backingResume, pendingEffect
					function proxyResume(effect) {
						backingResume
							? backingResume(effect)
							: void 0 === pendingEffect && (pendingEffect = effect)
					}
					const effect = new EffectPrimitive("Async")
					effect.effect_instruction_i0 = resume => {
						backingResume = resume
						pendingEffect && resume(pendingEffect)
					}
					effect.effect_instruction_i1 = blockingOn
					let cancelerRef, controllerRef
					if (1 !== this.effect_instruction_i0.length) {
						controllerRef = new AbortController()
						cancelerRef = internalCall(() =>
							this.effect_instruction_i0(proxyResume, controllerRef.signal),
						)
					} else
						cancelerRef = internalCall(() =>
							this.effect_instruction_i0(proxyResume),
						)
					return cancelerRef || controllerRef
						? onInterrupt(effect, _ => {
								controllerRef && controllerRef.abort()
								return cancelerRef ?? core_void_
							})
						: effect
				}),
			catchAll = Function_dual(2, (self, f) =>
				matchEffect(self, { onFailure: f, onSuccess: succeed }),
			),
			core_spanSymbol = Symbol.for("effect/SpanAnnotation"),
			originalSymbol = Symbol.for("effect/OriginalAnnotation"),
			capture = (obj, span) =>
				Option_isSome(span)
					? new Proxy(obj, {
							has: (target, p) =>
								p === core_spanSymbol || p === originalSymbol || p in target,
							get: (target, p) =>
								p === core_spanSymbol
									? span.value
									: p === originalSymbol
										? obj
										: target[p],
						})
					: obj,
			core_die = defect =>
				Predicate_isObject(defect) && !(core_spanSymbol in defect)
					? withFiberRuntime(fiber =>
							failCause(die(capture(defect, currentSpanFromFiber(fiber)))),
						)
					: failCause(die(defect)),
			core_either = self =>
				matchEffect(self, {
					onFailure: e => succeed(Either_left(e)),
					onSuccess: a => succeed(Either_right(a)),
				}),
			core_exit = self =>
				matchCause(self, { onFailure: exitFailCause, onSuccess: exitSucceed }),
			core_fail = error =>
				Predicate_isObject(error) && !(core_spanSymbol in error)
					? withFiberRuntime(fiber =>
							failCause(fail(capture(error, currentSpanFromFiber(fiber)))),
						)
					: failCause(fail(error)),
			failSync = evaluate => core_flatMap(sync(evaluate), core_fail),
			failCause = cause => {
				const effect = new EffectPrimitiveFailure("Failure")
				effect.effect_instruction_i0 = cause
				return effect
			},
			fiberId = withFiberRuntime(state => succeed(state.id())),
			fiberIdWith = f => withFiberRuntime(state => f(state.id())),
			core_flatMap = Function_dual(2, (self, f) => {
				const effect = new EffectPrimitive("OnSuccess")
				effect.effect_instruction_i0 = self
				effect.effect_instruction_i1 = f
				return effect
			}),
			step = self => {
				const effect = new EffectPrimitive("OnStep")
				effect.effect_instruction_i0 = self
				return effect
			},
			core_flatten = self => core_flatMap(self, Function_identity),
			matchCause = Function_dual(2, (self, options) =>
				matchCauseEffect(self, {
					onFailure: cause => succeed(options.onFailure(cause)),
					onSuccess: a => succeed(options.onSuccess(a)),
				}),
			),
			matchCauseEffect = Function_dual(2, (self, options) => {
				const effect = new EffectPrimitive("OnSuccessAndFailure")
				effect.effect_instruction_i0 = self
				effect.effect_instruction_i1 = options.onFailure
				effect.effect_instruction_i2 = options.onSuccess
				return effect
			}),
			matchEffect = Function_dual(2, (self, options) =>
				matchCauseEffect(self, {
					onFailure: cause => {
						if (cause_defects(cause).length > 0)
							return failCause(
								(self =>
									cause_match(self, {
										onEmpty: cause_empty,
										onFail: failure => die(failure),
										onDie: defect => die(defect),
										onInterrupt: fiberId => interrupt(fiberId),
										onSequential: (left, right) => sequential(left, right),
										onParallel: (left, right) => parallel(left, right),
									}))(cause),
							)
						const failures = (self =>
							Chunk_reverse(
								cause_reduce(self, esm_Chunk_empty(), (list, cause) =>
									"Fail" === cause._tag
										? Option_some(
												Function_pipe(list, Chunk_prepend(cause.error)),
											)
										: Option_none(),
								),
							))(cause)
						return failures.length > 0
							? options.onFailure(Chunk_unsafeHead(failures))
							: failCause(cause)
					},
					onSuccess: options.onSuccess,
				}),
			),
			forEachSequential = Function_dual(2, (self, f) =>
				suspend(() => {
					const arr = Array_fromIterable(self),
						ret = allocate(arr.length)
					let i = 0
					return core_as(
						whileLoop({
							while: () => i < arr.length,
							body: () => f(arr[i], i),
							step: b => {
								ret[i++] = b
							},
						}),
						ret,
					)
				}),
			),
			forEachSequentialDiscard = Function_dual(2, (self, f) =>
				suspend(() => {
					const arr = Array_fromIterable(self)
					let i = 0
					return whileLoop({
						while: () => i < arr.length,
						body: () => f(arr[i], i),
						step: () => {
							i++
						},
					})
				}),
			),
			core_interruptible = self => {
				const effect = new EffectPrimitive("UpdateRuntimeFlags")
				effect.effect_instruction_i0 = runtimeFlagsPatch_make((flag = 1), flag)
				var flag
				effect.effect_instruction_i1 = () => self
				return effect
			},
			core_map = Function_dual(2, (self, f) =>
				core_flatMap(self, a => sync(() => f(a))),
			),
			core_mapBoth = Function_dual(2, (self, options) =>
				matchEffect(self, {
					onFailure: e => failSync(() => options.onFailure(e)),
					onSuccess: a => sync(() => options.onSuccess(a)),
				}),
			),
			mapError = Function_dual(2, (self, f) =>
				matchCauseEffect(self, {
					onFailure: cause => {
						const either = failureOrCause(cause)
						switch (either._tag) {
							case "Left":
								return failSync(() => f(either.left))
							case "Right":
								return failCause(either.right)
						}
					},
					onSuccess: succeed,
				}),
			),
			onExit = Function_dual(2, (self, cleanup) =>
				uninterruptibleMask(restore =>
					matchCauseEffect(restore(self), {
						onFailure: cause1 => {
							const result = exitFailCause(cause1)
							return matchCauseEffect(cleanup(result), {
								onFailure: cause2 => exitFailCause(sequential(cause1, cause2)),
								onSuccess: () => result,
							})
						},
						onSuccess: success => {
							const result = exitSucceed(success)
							return core_zipRight(cleanup(result), result)
						},
					}),
				),
			),
			onInterrupt = Function_dual(2, (self, cleanup) =>
				onExit(
					self,
					exitMatch({
						onFailure: cause =>
							isInterruptedOnly(cause)
								? core_asVoid(
										cleanup(
											(self =>
												cause_reduce(self, HashSet_empty(), (set, cause) =>
													"Interrupt" === cause._tag
														? Option_some(
																Function_pipe(set, HashSet_add(cause.fiberId)),
															)
														: Option_none(),
												))(cause),
										),
									)
								: core_void_,
						onSuccess: () => core_void_,
					}),
				),
			),
			core_orElse = Function_dual(2, (self, that) =>
				attemptOrElse(self, that, succeed),
			),
			orDieWith = Function_dual(2, (self, f) =>
				matchEffect(self, {
					onFailure: e => core_die(f(e)),
					onSuccess: succeed,
				}),
			),
			succeed = value => {
				const effect = new EffectPrimitiveSuccess("Success")
				effect.effect_instruction_i0 = value
				return effect
			},
			suspend = effect => core_flatMap(sync(effect), Function_identity),
			sync = evaluate => {
				const effect = new EffectPrimitive("Sync")
				effect.effect_instruction_i0 = evaluate
				return effect
			},
			core_tap = Function_dual(2, (self, f) =>
				core_flatMap(self, a => {
					const b = "function" == typeof f ? f(a) : f
					return isEffect(b)
						? core_as(b, a)
						: Predicate_hasProperty((input = b), "then") &&
							  Predicate_isFunction(input.then)
							? core_async(resume => {
									b.then(
										_ => resume(succeed(a)),
										e => resume(core_fail(new UnknownException(e))),
									)
								})
							: succeed(a)
					var input
				}),
			),
			attemptOrElse = Function_dual(3, (self, that, onSuccess) =>
				matchCauseEffect(self, {
					onFailure: cause =>
						cause_defects(cause).length > 0
							? failCause(
									getOrThrow(
										(self =>
											cause_match(self, {
												onEmpty: Option_none(),
												onFail: failure => Option_some(die(failure)),
												onDie: defect => Option_some(die(defect)),
												onInterrupt: () => Option_none(),
												onSequential: (left, right) =>
													Option_isSome(left) && Option_isSome(right)
														? Option_some(sequential(left.value, right.value))
														: Option_isSome(left) && Option_isNone(right)
															? Option_some(left.value)
															: Option_isNone(left) && Option_isSome(right)
																? Option_some(right.value)
																: Option_none(),
												onParallel: (left, right) =>
													Option_isSome(left) && Option_isSome(right)
														? Option_some(parallel(left.value, right.value))
														: Option_isSome(left) && Option_isNone(right)
															? Option_some(left.value)
															: Option_isNone(left) && Option_isSome(right)
																? Option_some(right.value)
																: Option_none(),
											}))(cause),
									),
								)
							: that(),
					onSuccess,
				}),
			),
			uninterruptible = self => {
				const effect = new EffectPrimitive("UpdateRuntimeFlags")
				effect.effect_instruction_i0 = RuntimeFlagsPatch_disable(1)
				effect.effect_instruction_i1 = () => self
				return effect
			},
			uninterruptibleMask = f =>
				custom(f, function () {
					const effect = new EffectPrimitive("UpdateRuntimeFlags")
					effect.effect_instruction_i0 = RuntimeFlagsPatch_disable(1)
					effect.effect_instruction_i1 = oldFlags =>
						interruption(oldFlags)
							? internalCall(() =>
									this.effect_instruction_i0(core_interruptible),
								)
							: internalCall(() => this.effect_instruction_i0(uninterruptible))
					return effect
				}),
			core_void_ = succeed(void 0),
			whenEffect = Function_dual(2, (self, condition) =>
				core_flatMap(condition, b =>
					b
						? Function_pipe(self, core_map(Option_some))
						: succeed(Option_none()),
				),
			),
			whileLoop = options => {
				const effect = new EffectPrimitive("While")
				effect.effect_instruction_i0 = options.while
				effect.effect_instruction_i1 = options.body
				effect.effect_instruction_i2 = options.step
				return effect
			},
			withConcurrency = Function_dual(2, (self, concurrency) =>
				fiberRefLocally(self, currentConcurrency, concurrency),
			),
			withRuntimeFlags = Function_dual(2, (self, update) => {
				const effect = new EffectPrimitive("UpdateRuntimeFlags")
				effect.effect_instruction_i0 = update
				effect.effect_instruction_i1 = () => self
				return effect
			}),
			yieldNow = options => {
				const effect = new EffectPrimitive("Yield")
				return void 0 !== options?.priority
					? withSchedulingPriority(effect, options.priority)
					: effect
			},
			core_zip = Function_dual(2, (self, that) =>
				core_flatMap(self, a => core_map(that, b => [a, b])),
			),
			core_zipLeft = Function_dual(2, (self, that) =>
				core_flatMap(self, a => core_as(that, a)),
			),
			core_zipRight = Function_dual(2, (self, that) =>
				core_flatMap(self, () => that),
			),
			core_zipWith = Function_dual(3, (self, that, f) =>
				core_flatMap(self, a => core_map(that, b => f(a, b))),
			),
			interruptAsFiber = Function_dual(2, (self, fiberId) =>
				core_flatMap(self.interruptAsFork(fiberId), () => self.await),
			),
			logLevelFatal =
				(Number.MIN_SAFE_INTEGER,
				{
					_tag: "Fatal",
					syslog: 2,
					label: "FATAL",
					ordinal: 5e4,
					pipe() {
						return Pipeable_pipeArguments(this, arguments)
					},
				}),
			logLevelError = {
				_tag: "Error",
				syslog: 3,
				label: "ERROR",
				ordinal: 4e4,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			logLevelWarning = {
				_tag: "Warning",
				syslog: 4,
				label: "WARN",
				ordinal: 3e4,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			logLevelInfo = {
				_tag: "Info",
				syslog: 6,
				label: "INFO",
				ordinal: 2e4,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			logLevelDebug = {
				_tag: "Debug",
				syslog: 7,
				label: "DEBUG",
				ordinal: 1e4,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			logLevelTrace = {
				_tag: "Trace",
				syslog: 7,
				label: "TRACE",
				ordinal: 0,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			FiberRefTypeId = (Number.MAX_SAFE_INTEGER, Symbol.for("effect/FiberRef")),
			fiberRefVariance = { _A: _ => _ },
			fiberRefGet = self => fiberRefModify(self, a => [a, a]),
			fiberRefGetWith = Function_dual(2, (self, f) =>
				core_flatMap(fiberRefGet(self), f),
			),
			fiberRefSet = Function_dual(2, (self, value) =>
				fiberRefModify(self, () => [void 0, value]),
			),
			fiberRefModify = Function_dual(2, (self, f) =>
				withFiberRuntime(state => {
					const [b, a] = f(state.getFiberRef(self))
					state.setFiberRef(self, a)
					return succeed(b)
				}),
			),
			fiberRefLocally = Function_dual(3, (use, self, value) =>
				acquireUseRelease(
					core_zipLeft(fiberRefGet(self), fiberRefSet(self, value)),
					() => use,
					oldValue => fiberRefSet(self, oldValue),
				),
			),
			fiberRefLocallyWith = Function_dual(3, (use, self, f) =>
				fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))),
			),
			fiberRefUnsafeMake = (initial, options) =>
				fiberRefUnsafeMakePatch(initial, {
					differ: differ_update(),
					fork: options?.fork ?? Function_identity,
					join: options?.join,
				}),
			fiberRefUnsafeMakeContext = initial => {
				const differ = differ_make({
					empty: differ_contextPatch_empty(),
					combine: (first, second) => contextPatch_combine(second)(first),
					diff: (oldValue, newValue) =>
						((oldValue, newValue) => {
							const missingServices = new Map(oldValue.unsafeMap)
							let patch = differ_contextPatch_empty()
							for (const [tag, newService] of newValue.unsafeMap.entries())
								if (missingServices.has(tag)) {
									const old = missingServices.get(tag)
									missingServices.delete(tag)
									equals(old, newService) ||
										(patch = contextPatch_combine(
											makeUpdateService(tag, () => newService),
										)(patch))
								} else {
									missingServices.delete(tag)
									patch = contextPatch_combine(makeAddService(tag, newService))(
										patch,
									)
								}
							for (const [tag] of missingServices.entries())
								patch = contextPatch_combine(makeRemoveService(tag))(patch)
							return patch
						})(oldValue, newValue),
					patch: (patch, oldValue) => contextPatch_patch(oldValue)(patch),
				})
				return fiberRefUnsafeMakePatch(initial, { differ, fork: differ.empty })
			},
			fiberRefUnsafeMakePatch = (initial, options) => ({
				[FiberRefTypeId]: fiberRefVariance,
				initial,
				diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
				combine: (first, second) => options.differ.combine(first, second),
				patch: patch => oldValue => options.differ.patch(patch, oldValue),
				fork: options.fork,
				join: options.join ?? ((_, n) => n),
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			}),
			fiberRefUnsafeMakeRuntimeFlags = initial =>
				fiberRefUnsafeMakePatch(initial, { differ, fork: differ.empty }),
			currentContext = globalValue(
				Symbol.for("effect/FiberRef/currentContext"),
				() => fiberRefUnsafeMakeContext(Context_empty()),
			),
			currentSchedulingPriority = globalValue(
				Symbol.for("effect/FiberRef/currentSchedulingPriority"),
				() => fiberRefUnsafeMake(0),
			),
			currentMaxOpsBeforeYield = globalValue(
				Symbol.for("effect/FiberRef/currentMaxOpsBeforeYield"),
				() => fiberRefUnsafeMake(2048),
			),
			currentLogAnnotations = globalValue(
				Symbol.for("effect/FiberRef/currentLogAnnotation"),
				() => fiberRefUnsafeMake(HashMap_empty()),
			),
			currentLogLevel = globalValue(
				Symbol.for("effect/FiberRef/currentLogLevel"),
				() => fiberRefUnsafeMake(logLevelInfo),
			),
			currentLogSpan = globalValue(
				Symbol.for("effect/FiberRef/currentLogSpan"),
				() => fiberRefUnsafeMake(List_empty()),
			),
			withSchedulingPriority = Function_dual(2, (self, scheduler) =>
				fiberRefLocally(self, currentSchedulingPriority, scheduler),
			),
			currentConcurrency = globalValue(
				Symbol.for("effect/FiberRef/currentConcurrency"),
				() => fiberRefUnsafeMake("unbounded"),
			),
			currentRequestBatching = globalValue(
				Symbol.for("effect/FiberRef/currentRequestBatching"),
				() => fiberRefUnsafeMake(!0),
			),
			currentUnhandledErrorLogLevel = globalValue(
				Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"),
				() => fiberRefUnsafeMake(Option_some(logLevelDebug)),
			),
			currentMetricLabels = globalValue(
				Symbol.for("effect/FiberRef/currentMetricLabels"),
				() =>
					(initial => {
						const differ = (differ =>
							differ_make({
								empty: differ_readonlyArrayPatch_empty(),
								combine: (first, second) =>
									readonlyArrayPatch_combine(first, second),
								diff: (oldValue, newValue) =>
									(options => {
										let i = 0,
											patch = differ_readonlyArrayPatch_empty()
										for (
											;
											i < options.oldValue.length &&
											i < options.newValue.length;

										) {
											const oldElement = options.oldValue[i],
												newElement = options.newValue[i],
												valuePatch = options.differ.diff(oldElement, newElement)
											equals(valuePatch, options.differ.empty) ||
												(patch = readonlyArrayPatch_combine(
													patch,
													readonlyArrayPatch_makeUpdate(i, valuePatch),
												))
											i += 1
										}
										i < options.oldValue.length &&
											(patch = readonlyArrayPatch_combine(
												patch,
												((from, until) => {
													const o = Object.create(readonlyArrayPatch_SliceProto)
													o.from = 0
													o.until = until
													return o
												})(0, i),
											))
										i < options.newValue.length &&
											(patch = readonlyArrayPatch_combine(
												patch,
												(values => {
													const o = Object.create(
														readonlyArrayPatch_AppendProto,
													)
													o.values = values
													return o
												})(Array_drop(i)(options.newValue)),
											))
										return patch
									})({ oldValue, newValue, differ }),
								patch: (patch, oldValue) =>
									readonlyArrayPatch_patch(patch, oldValue, differ),
							}))(differ_update())
						return fiberRefUnsafeMakePatch([], { differ, fork: differ.empty })
					})(),
			),
			currentForkScopeOverride = globalValue(
				Symbol.for("effect/FiberRef/currentForkScopeOverride"),
				() =>
					fiberRefUnsafeMake(Option_none(), {
						fork: () => Option_none(),
						join: (parent, _) => parent,
					}),
			),
			currentInterruptedCause = globalValue(
				Symbol.for("effect/FiberRef/currentInterruptedCause"),
				() =>
					fiberRefUnsafeMake(cause_empty, {
						fork: () => cause_empty,
						join: (parent, _) => parent,
					}),
			),
			ScopeTypeId = Symbol.for("effect/Scope"),
			CloseableScopeTypeId = Symbol.for("effect/CloseableScope"),
			scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer),
			scopeClose = (self, exit) => self.close(exit),
			scopeFork = (self, strategy) => self.fork(strategy),
			YieldableError = (function () {
				class YieldableError extends globalThis.Error {
					commit() {
						return core_fail(this)
					}
					toJSON() {
						return { ...this }
					}
					[Inspectable_NodeInspectSymbol]() {
						return this.toString !== globalThis.Error.prototype.toString
							? this.stack
								? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}`
								: this.toString()
							: "Bun" in globalThis
								? pretty(fail(this), { renderErrorCause: !0 })
								: this
					}
				}
				Object.assign(YieldableError.prototype, StructuralCommitPrototype)
				return YieldableError
			})(),
			makeException = (proto, tag) => {
				class Base extends YieldableError {
					_tag = tag
				}
				Object.assign(Base.prototype, proto)
				Base.prototype.name = tag
				return Base
			},
			RuntimeExceptionTypeId = Symbol.for(
				"effect/Cause/errors/RuntimeException",
			),
			RuntimeException = makeException(
				{ [RuntimeExceptionTypeId]: RuntimeExceptionTypeId },
				"RuntimeException",
			),
			InterruptedExceptionTypeId = Symbol.for(
				"effect/Cause/errors/InterruptedException",
			),
			isInterruptedException = u =>
				Predicate_hasProperty(u, InterruptedExceptionTypeId),
			NoSuchElementExceptionTypeId = Symbol.for(
				"effect/Cause/errors/NoSuchElement",
			),
			NoSuchElementException = makeException(
				{ [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId },
				"NoSuchElementException",
			),
			UnknownExceptionTypeId = Symbol.for(
				"effect/Cause/errors/UnknownException",
			),
			UnknownException = (function () {
				class UnknownException extends YieldableError {
					cause
					_tag = "UnknownException"
					error
					constructor(cause, message) {
						super(message ?? "An unknown error occurred", { cause })
						this.cause = cause
						this.error = cause
					}
				}
				Object.assign(UnknownException.prototype, {
					[UnknownExceptionTypeId]: UnknownExceptionTypeId,
					name: "UnknownException",
				})
				return UnknownException
			})(),
			exitIsExit = u =>
				isEffect(u) &&
				"_tag" in u &&
				("Success" === u._tag || "Failure" === u._tag),
			exitAs = Function_dual(2, (self, value) => {
				switch (self._tag) {
					case "Failure":
						return exitFailCause(self.effect_instruction_i0)
					case "Success":
						return exitSucceed(value)
				}
			}),
			exitAsVoid = self => exitAs(self, void 0),
			exitCollectAll = (exits, options) =>
				exitCollectAllInternal(
					exits,
					options?.parallel ? parallel : sequential,
				),
			exitDie = defect => exitFailCause(die(defect)),
			exitFail = error => exitFailCause(fail(error)),
			exitFailCause = cause => {
				const effect = new EffectPrimitiveFailure("Failure")
				effect.effect_instruction_i0 = cause
				return effect
			},
			exitMap = Function_dual(2, (self, f) => {
				switch (self._tag) {
					case "Failure":
						return exitFailCause(self.effect_instruction_i0)
					case "Success":
						return exitSucceed(f(self.effect_instruction_i0))
				}
			}),
			exitMatch = Function_dual(2, (self, { onFailure, onSuccess }) => {
				switch (self._tag) {
					case "Failure":
						return onFailure(self.effect_instruction_i0)
					case "Success":
						return onSuccess(self.effect_instruction_i0)
				}
			}),
			exitMatchEffect = Function_dual(2, (self, { onFailure, onSuccess }) => {
				switch (self._tag) {
					case "Failure":
						return onFailure(self.effect_instruction_i0)
					case "Success":
						return onSuccess(self.effect_instruction_i0)
				}
			}),
			exitSucceed = value => {
				const effect = new EffectPrimitiveSuccess("Success")
				effect.effect_instruction_i0 = value
				return effect
			},
			exitVoid = exitSucceed(void 0),
			exitZipWith = Function_dual(3, (self, that, { onFailure, onSuccess }) => {
				switch (self._tag) {
					case "Failure":
						switch (that._tag) {
							case "Success":
								return exitFailCause(self.effect_instruction_i0)
							case "Failure":
								return exitFailCause(
									onFailure(
										self.effect_instruction_i0,
										that.effect_instruction_i0,
									),
								)
						}
					case "Success":
						switch (that._tag) {
							case "Success":
								return exitSucceed(
									onSuccess(
										self.effect_instruction_i0,
										that.effect_instruction_i0,
									),
								)
							case "Failure":
								return exitFailCause(that.effect_instruction_i0)
						}
				}
			}),
			exitCollectAllInternal = (exits, combineCauses) => {
				const list = Chunk_fromIterable(exits)
				return isNonEmpty(list)
					? Function_pipe(
							Chunk_tailNonEmpty(list),
							Array_reduce(
								Function_pipe(Chunk_headNonEmpty(list), exitMap(Chunk_of)),
								(accumulator, current) =>
									Function_pipe(
										accumulator,
										exitZipWith(current, {
											onSuccess: (list, value) =>
												Function_pipe(list, Chunk_prepend(value)),
											onFailure: combineCauses,
										}),
									),
							),
							exitMap(Chunk_reverse),
							exitMap(chunk => toReadonlyArray(chunk)),
							Option_some,
						)
					: Option_none()
			},
			deferredUnsafeMake = fiberId => {
				return {
					[DeferredTypeId]: deferredVariance,
					state: MutableRef_make(
						((joiners = []), { _tag: "Pending", joiners }),
					),
					blockingOn: fiberId,
					pipe() {
						return Pipeable_pipeArguments(this, arguments)
					},
				}
				var joiners
			},
			deferredAwait = self =>
				core_async(resume => {
					const state = MutableRef_get(self.state)
					switch (state._tag) {
						case "Done":
							return resume(state.effect)
						case "Pending":
							state.joiners.push(resume)
							return deferredInterruptJoiner(self, resume)
					}
				}, self.blockingOn),
			deferredCompleteWith = Function_dual(2, (self, effect) =>
				sync(() => {
					const state = MutableRef_get(self.state)
					switch (state._tag) {
						case "Done":
							return !1
						case "Pending":
							MutableRef_set(self.state, done(effect))
							for (let i = 0, len = state.joiners.length; i < len; i++)
								state.joiners[i](effect)
							return !0
					}
				}),
			),
			deferredFailCause = Function_dual(2, (self, cause) =>
				deferredCompleteWith(self, failCause(cause)),
			),
			deferredSucceed = Function_dual(2, (self, value) =>
				deferredCompleteWith(self, succeed(value)),
			),
			deferredUnsafeDone = (self, effect) => {
				const state = MutableRef_get(self.state)
				if ("Pending" === state._tag) {
					MutableRef_set(self.state, done(effect))
					for (let i = 0, len = state.joiners.length; i < len; i++)
						state.joiners[i](effect)
				}
			},
			deferredInterruptJoiner = (self, joiner) =>
				sync(() => {
					const state = MutableRef_get(self.state)
					if ("Pending" === state._tag) {
						const index = state.joiners.indexOf(joiner)
						index >= 0 && state.joiners.splice(index, 1)
					}
				}),
			constContext = fiberRefGet(currentContext),
			contextWithEffect = f => core_flatMap(constContext, f),
			provideContext = Function_dual(2, (self, context) =>
				fiberRefLocally(currentContext, context)(self),
			),
			provideSomeContext = Function_dual(2, (self, context) =>
				fiberRefLocallyWith(currentContext, parent =>
					Context_merge(parent, context),
				)(self),
			),
			mapInputContext = Function_dual(2, (self, f) =>
				contextWithEffect(context => provideContext(self, f(context))),
			),
			currentSpanFromFiber = fiber => {
				const span = fiber
					.getFiberRef(currentContext)
					.unsafeMap.get(spanTag.key)
				return void 0 !== span && "Span" === span._tag
					? Option_some(span)
					: Option_none()
			},
			ClockTypeId = Symbol.for("effect/Clock"),
			clockTag = GenericTag("effect/Clock"),
			globalClockScheduler = {
				unsafeSchedule(task, duration) {
					const millis = toMillis(duration)
					if (millis > 2147483647) return constFalse
					let completed = !1
					const handle = setTimeout(() => {
						completed = !0
						task()
					}, millis)
					return () => {
						clearTimeout(handle)
						return !completed
					}
				},
			},
			performanceNowNanos = (function () {
				const bigint1e6 = BigInt(1e6)
				if ("undefined" == typeof performance)
					return () => BigInt(Date.now()) * bigint1e6
				if (
					"number" == typeof performance.timeOrigin &&
					0 === performance.timeOrigin
				)
					return () => BigInt(Math.round(1e6 * performance.now()))
				const origin =
					BigInt(Date.now()) * bigint1e6 -
					BigInt(Math.round(1e6 * performance.now()))
				return () => origin + BigInt(Math.round(1e6 * performance.now()))
			})(),
			processOrPerformanceNow = (function () {
				const processHrtime =
					"object" == typeof process &&
					"hrtime" in process &&
					"function" == typeof process.hrtime.bigint
						? process.hrtime
						: void 0
				if (!processHrtime) return performanceNowNanos
				const origin = performanceNowNanos() - processHrtime.bigint()
				return () => origin + processHrtime.bigint()
			})()
		class ClockImpl {
			[ClockTypeId] = ClockTypeId
			unsafeCurrentTimeMillis() {
				return Date.now()
			}
			unsafeCurrentTimeNanos() {
				return processOrPerformanceNow()
			}
			currentTimeMillis = sync(() => this.unsafeCurrentTimeMillis())
			currentTimeNanos = sync(() => this.unsafeCurrentTimeNanos())
			scheduler() {
				return succeed(globalClockScheduler)
			}
			sleep(duration) {
				return core_async(resume => {
					const canceler = globalClockScheduler.unsafeSchedule(
						() => resume(core_void_),
						duration,
					)
					return core_asVoid(sync(canceler))
				})
			}
		}
		const clock_make = () => new ClockImpl(),
			Number_Order = Order_number,
			Number_clamp = clamp(Number_Order),
			RegExp_escape = string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&"),
			ConfigErrorTypeId = Symbol.for("effect/ConfigError"),
			configError_proto = {
				_tag: "ConfigError",
				[ConfigErrorTypeId]: ConfigErrorTypeId,
			},
			And = (self, that) => {
				const error = Object.create(configError_proto)
				error._op = "And"
				error.left = self
				error.right = that
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `${this.left} and ${this.right}`
					},
				})
				return error
			},
			Or = (self, that) => {
				const error = Object.create(configError_proto)
				error._op = "Or"
				error.left = self
				error.right = that
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `${this.left} or ${this.right}`
					},
				})
				return error
			},
			InvalidData = (path, message, options = { pathDelim: "." }) => {
				const error = Object.create(configError_proto)
				error._op = "InvalidData"
				error.path = path
				error.message = message
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `(Invalid data at ${Function_pipe(this.path, join(options.pathDelim))}: "${this.message}")`
					},
				})
				return error
			},
			MissingData = (path, message, options = { pathDelim: "." }) => {
				const error = Object.create(configError_proto)
				error._op = "MissingData"
				error.path = path
				error.message = message
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `(Missing data at ${Function_pipe(this.path, join(options.pathDelim))}: "${this.message}")`
					},
				})
				return error
			},
			SourceUnavailable = (
				path,
				message,
				cause,
				options = { pathDelim: "." },
			) => {
				const error = Object.create(configError_proto)
				error._op = "SourceUnavailable"
				error.path = path
				error.message = message
				error.cause = cause
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `(Source unavailable at ${Function_pipe(this.path, join(options.pathDelim))}: "${this.message}")`
					},
				})
				return error
			},
			Unsupported = (path, message, options = { pathDelim: "." }) => {
				const error = Object.create(configError_proto)
				error._op = "Unsupported"
				error.path = path
				error.message = message
				Object.defineProperty(error, "toString", {
					enumerable: !1,
					value() {
						return `(Unsupported operation at ${Function_pipe(this.path, join(options.pathDelim))}: "${this.message}")`
					},
				})
				return error
			},
			prefixed = Function_dual(2, (self, prefix) => {
				switch (self._op) {
					case "And":
						return And(
							prefixed(self.left, prefix),
							prefixed(self.right, prefix),
						)
					case "Or":
						return Or(prefixed(self.left, prefix), prefixed(self.right, prefix))
					case "InvalidData":
						return InvalidData([...prefix, ...self.path], self.message)
					case "MissingData":
						return MissingData([...prefix, ...self.path], self.message)
					case "SourceUnavailable":
						return SourceUnavailable(
							[...prefix, ...self.path],
							self.message,
							self.cause,
						)
					case "Unsupported":
						return Unsupported([...prefix, ...self.path], self.message)
				}
			}),
			pathPatch_empty = { _tag: "Empty" },
			patch = Function_dual(2, (path, patch) => {
				let input = List_of(patch),
					output = path
				for (; isCons(input); ) {
					const patch = input.head
					switch (patch._tag) {
						case "Empty":
							input = input.tail
							break
						case "AndThen":
							input = cons(patch.first, cons(patch.second, input.tail))
							break
						case "MapName":
							output = Array_map(output, patch.f)
							input = input.tail
							break
						case "Nested":
							output = Array_prepend(output, patch.name)
							input = input.tail
							break
						case "Unnested":
							if (!Function_pipe(Array_head(output), contains(patch.name)))
								return Either_left(
									MissingData(
										output,
										`Expected ${patch.name} to be in path in ConfigProvider#unnested`,
									),
								)
							output = tailNonEmpty(output)
							input = input.tail
					}
				}
				return Either_right(output)
			}),
			concat = (l, r) => [...l, ...r],
			ConfigProviderTypeId = Symbol.for("effect/ConfigProvider"),
			configProviderTag = GenericTag("effect/ConfigProvider"),
			FlatConfigProviderTypeId = Symbol.for("effect/ConfigProviderFlat"),
			configProvider_make = options => ({
				[ConfigProviderTypeId]: ConfigProviderTypeId,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
				...options,
			}),
			fromEnv = config => {
				const { pathDelim, seqDelim } = Object.assign(
						{},
						{ pathDelim: "_", seqDelim: "," },
						config,
					),
					getEnv = () =>
						"undefined" != typeof process &&
						"env" in process &&
						"object" == typeof process.env
							? process.env
							: {}
				return (
					(flat =
						((options = {
							load: (path, primitive, split = !0) => {
								const pathString = (path =>
										Function_pipe(path, join(pathDelim)))(path),
									current = getEnv()
								return Function_pipe(
									pathString in current
										? Option_some(current[pathString])
										: Option_none(),
									mapError(() =>
										MissingData(
											path,
											`Expected ${pathString} to exist in the process context`,
										),
									),
									core_flatMap(value =>
										parsePrimitive(value, path, primitive, seqDelim, split),
									),
								)
							},
							enumerateChildren: path =>
								sync(() => {
									const current = getEnv(),
										filteredKeyPaths = Object.keys(current)
											.map(value => value.toUpperCase().split(pathDelim))
											.filter(keyPath => {
												for (let i = 0; i < path.length; i++) {
													const pathComponent = Function_pipe(
															path,
															Array_unsafeGet(i),
														),
														currentElement = keyPath[i]
													if (
														void 0 === currentElement ||
														pathComponent !== currentElement
													)
														return !1
												}
												return !0
											})
											.flatMap(keyPath =>
												keyPath.slice(path.length, path.length + 1),
											)
									return (elements => {
										const set = hashSet_beginMutation(internal_hashSet_empty())
										for (const value of elements) hashSet_add(set, value)
										return hashSet_endMutation(set)
									})(filteredKeyPaths)
								}),
							patch: pathPatch_empty,
						}),
						{
							[FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
							patch: options.patch,
							load: (path, config, split = !0) =>
								options.load(path, config, split),
							enumerateChildren: options.enumerateChildren,
						})),
					configProvider_make({
						load: config =>
							core_flatMap(fromFlatLoop(flat, [], config, !1), chunk =>
								match(Array_head(chunk), {
									onNone: () =>
										core_fail(
											MissingData(
												[],
												`Expected a single value having structure: ${config}`,
											),
										),
									onSome: succeed,
								}),
							),
						flattened: flat,
					})
				)
				var flat, options
			},
			fromFlatLoop = (flat, prefix, config, split) => {
				const op = config
				switch (op._tag) {
					case "Constant":
						return succeed(Array_of(op.value))
					case "Described":
						return suspend(() => fromFlatLoop(flat, prefix, op.config, split))
					case "Fail":
						return core_fail(MissingData(prefix, op.message))
					case "Fallback":
						return Function_pipe(
							suspend(() => fromFlatLoop(flat, prefix, op.first, split)),
							catchAll(error1 =>
								op.condition(error1)
									? Function_pipe(
											fromFlatLoop(flat, prefix, op.second, split),
											catchAll(error2 => core_fail(Or(error1, error2))),
										)
									: core_fail(error1),
							),
						)
					case "Lazy":
						return suspend(() => fromFlatLoop(flat, prefix, op.config(), split))
					case "MapOrFail":
						return suspend(() =>
							Function_pipe(
								fromFlatLoop(flat, prefix, op.original, split),
								core_flatMap(
									forEachSequential(a =>
										Function_pipe(
											op.mapOrFail(a),
											mapError(
												prefixed(
													((path, config) => {
														let op = config
														if ("Nested" === op._tag) {
															const out = path.slice()
															for (; "Nested" === op._tag; ) {
																out.push(op.name)
																op = op.config
															}
															return out
														}
														return path
													})(prefix, op.original),
												),
											),
										),
									),
								),
							),
						)
					case "Nested":
						return suspend(() =>
							fromFlatLoop(
								flat,
								concat(prefix, Array_of(op.name)),
								op.config,
								split,
							),
						)
					case "Primitive":
						return Function_pipe(
							patch(prefix, flat.patch),
							core_flatMap(prefix =>
								Function_pipe(
									flat.load(prefix, op, split),
									core_flatMap(values => {
										if (0 === values.length) {
											const name = Function_pipe(
												(self =>
													isNonEmptyReadonlyArray(self)
														? Option_some(lastNonEmpty(self))
														: Option_none())(prefix),
												getOrElse(() => "<n/a>"),
											)
											return core_fail(
												MissingData(
													[],
													`Expected ${op.description} with name ${name}`,
												),
											)
										}
										return succeed(values)
									}),
								),
							),
						)
					case "Sequence":
						return Function_pipe(
							patch(prefix, flat.patch),
							core_flatMap(patchedPrefix =>
								Function_pipe(
									flat.enumerateChildren(patchedPrefix),
									core_flatMap(indicesFrom),
									core_flatMap(indices =>
										0 === indices.length
											? suspend(() =>
													core_map(
														fromFlatLoop(flat, patchedPrefix, op.config, !0),
														Array_of,
													),
												)
											: Function_pipe(
													forEachSequential(indices, index =>
														fromFlatLoop(
															flat,
															Array_append(prefix, `[${index}]`),
															op.config,
															!0,
														),
													),
													core_map(chunkChunk => {
														const flattened = Array_flatten(chunkChunk)
														return 0 === flattened.length
															? Array_of([])
															: Array_of(flattened)
													}),
												),
									),
								),
							),
						)
					case "HashMap":
						return suspend(() =>
							Function_pipe(
								patch(prefix, flat.patch),
								core_flatMap(prefix =>
									Function_pipe(
										flat.enumerateChildren(prefix),
										core_flatMap(keys =>
											Function_pipe(
												keys,
												forEachSequential(key =>
													fromFlatLoop(
														flat,
														concat(prefix, Array_of(key)),
														op.valueConfig,
														split,
													),
												),
												core_map(matrix =>
													0 === matrix.length
														? Array_of(HashMap_empty())
														: Function_pipe(
																transpose(matrix),
																Array_map(values =>
																	(entries => {
																		const map = beginMutation(
																			internal_hashMap_empty(),
																		)
																		for (const entry of entries)
																			hashMap_set(map, entry[0], entry[1])
																		return (self => {
																			self._editable = !1
																			return self
																		})(map)
																	})(
																		Array_zip(Array_fromIterable(keys), values),
																	),
																),
															),
												),
											),
										),
									),
								),
							),
						)
					case "ZipWith":
						return suspend(() =>
							Function_pipe(
								fromFlatLoop(flat, prefix, op.left, split),
								core_either,
								core_flatMap(left =>
									Function_pipe(
										fromFlatLoop(flat, prefix, op.right, split),
										core_either,
										core_flatMap(right => {
											if (Either_isLeft(left) && Either_isLeft(right))
												return core_fail(And(left.left, right.left))
											if (Either_isLeft(left) && Either_isRight(right))
												return core_fail(left.left)
											if (Either_isRight(left) && Either_isLeft(right))
												return core_fail(right.left)
											if (Either_isRight(left) && Either_isRight(right)) {
												const path = Function_pipe(prefix, join(".")),
													fail = fromFlatLoopFail(prefix, path),
													[lefts, rights] = ((
														leftDef,
														rightDef,
														left,
														right,
													) => {
														const leftPad = Array_unfold(left.length, index =>
																index >= right.length
																	? Option_none()
																	: Option_some([leftDef(index), index + 1]),
															),
															rightPad = Array_unfold(right.length, index =>
																index >= left.length
																	? Option_none()
																	: Option_some([rightDef(index), index + 1]),
															)
														return [
															concat(left, leftPad),
															concat(right, rightPad),
														]
													})(
														fail,
														fail,
														Function_pipe(left.right, Array_map(Either_right)),
														Function_pipe(right.right, Array_map(Either_right)),
													)
												return Function_pipe(
													lefts,
													Array_zip(rights),
													forEachSequential(([left, right]) =>
														Function_pipe(
															core_zip(left, right),
															core_map(([left, right]) => op.zip(left, right)),
														),
													),
												)
											}
											throw new Error(
												"BUG: ConfigProvider.fromFlatLoop - please report an issue at https://github.com/Effect-TS/effect/issues",
											)
										}),
									),
								),
							),
						)
				}
			},
			fromFlatLoopFail = (prefix, path) => index =>
				Either_left(
					MissingData(
						prefix,
						`The element at index ${index} in a sequence at path "${path}" was missing`,
					),
				),
			parsePrimitive = (text, path, primitive, delimiter, split) =>
				split
					? Function_pipe(
							((text, delim) =>
								text.split(new RegExp(`\\s*${RegExp_escape(delim)}\\s*`)))(
								text,
								delimiter,
							),
							forEachSequential(char => primitive.parse(char.trim())),
							mapError(prefixed(path)),
						)
					: Function_pipe(
							primitive.parse(text),
							core_mapBoth({ onFailure: prefixed(path), onSuccess: Array_of }),
						),
			transpose = array =>
				Object.keys(array[0]).map(column => array.map(row => row[column])),
			indicesFrom = quotedIndices =>
				Function_pipe(
					forEachSequential(quotedIndices, parseQuotedIndex),
					core_mapBoth({ onFailure: () => [], onSuccess: sort(Number_Order) }),
					core_either,
					core_map(Either_merge),
				),
			QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/,
			parseQuotedIndex = str => {
				const match = str.match(QUOTED_INDEX_REGEX)
				if (null !== match) {
					const matchedIndex = match[2]
					return Function_pipe(
						void 0 !== matchedIndex && matchedIndex.length > 0
							? Option_some(matchedIndex)
							: Option_none(),
						flatMap(parseInteger),
					)
				}
				return Option_none()
			},
			parseInteger = str => {
				const parsedIndex = Number.parseInt(str)
				return Number.isNaN(parsedIndex)
					? Option_none()
					: Option_some(parsedIndex)
			},
			console_TypeId = Symbol.for("effect/Console"),
			consoleTag = GenericTag("effect/Console"),
			defaultConsole = {
				[console_TypeId]: console_TypeId,
				assert: (condition, ...args) =>
					sync(() => {
						console.assert(condition, ...args)
					}),
				clear: sync(() => {
					console.clear()
				}),
				count: label =>
					sync(() => {
						console.count(label)
					}),
				countReset: label =>
					sync(() => {
						console.countReset(label)
					}),
				debug: (...args) =>
					sync(() => {
						console.debug(...args)
					}),
				dir: (item, options) =>
					sync(() => {
						console.dir(item, options)
					}),
				dirxml: (...args) =>
					sync(() => {
						console.dirxml(...args)
					}),
				error: (...args) =>
					sync(() => {
						console.error(...args)
					}),
				group: options =>
					sync(
						options?.collapsed
							? () => console.groupCollapsed(options?.label)
							: () => console.group(options?.label),
					),
				groupEnd: sync(() => {
					console.groupEnd()
				}),
				info: (...args) =>
					sync(() => {
						console.info(...args)
					}),
				log: (...args) =>
					sync(() => {
						console.log(...args)
					}),
				table: (tabularData, properties) =>
					sync(() => {
						console.table(tabularData, properties)
					}),
				time: label => sync(() => console.time(label)),
				timeEnd: label => sync(() => console.timeEnd(label)),
				timeLog: (label, ...args) =>
					sync(() => {
						console.timeLog(label, ...args)
					}),
				trace: (...args) =>
					sync(() => {
						console.trace(...args)
					}),
				warn: (...args) =>
					sync(() => {
						console.warn(...args)
					}),
				unsafe: console,
			},
			RandomTypeId = Symbol.for("effect/Random"),
			randomTag = GenericTag("effect/Random")
		class RandomImpl {
			seed;
			[RandomTypeId] = RandomTypeId
			PRNG
			constructor(seed) {
				this.seed = seed
				this.PRNG = new PCGRandom(seed)
			}
			get next() {
				return sync(() => this.PRNG.number())
			}
			get nextBoolean() {
				return core_map(this.next, n => n > 0.5)
			}
			get nextInt() {
				return sync(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER))
			}
			nextRange(min, max) {
				return core_map(this.next, n => (max - min) * n + min)
			}
			nextIntBetween(min, max) {
				return sync(() => this.PRNG.integer(max - min) + min)
			}
			shuffle(elements) {
				return shuffleWith(elements, n => this.nextIntBetween(0, n))
			}
		}
		const shuffleWith = (elements, nextIntBounded) =>
				suspend(() =>
					Function_pipe(
						sync(() => Array.from(elements)),
						core_flatMap(buffer => {
							const numbers = []
							for (let i = buffer.length; i >= 2; i -= 1) numbers.push(i)
							return Function_pipe(
								numbers,
								forEachSequentialDiscard(n =>
									Function_pipe(
										nextIntBounded(n),
										core_map(k => random_swap(buffer, n - 1, k)),
									),
								),
								core_as(Chunk_fromIterable(buffer)),
							)
						}),
					),
				),
			random_swap = (buffer, index1, index2) => {
				const tmp = buffer[index1]
				buffer[index1] = buffer[index2]
				buffer[index2] = tmp
				return buffer
			},
			random_make = seed => new RandomImpl(Hash_hash(seed)),
			liveServices = Function_pipe(
				Context_empty(),
				Context_add(clockTag, clock_make()),
				Context_add(consoleTag, defaultConsole),
				Context_add(randomTag, random_make(Math.random())),
				Context_add(configProviderTag, fromEnv()),
				Context_add(tracerTag, nativeTracer),
			),
			currentServices = globalValue(
				Symbol.for("effect/DefaultServices/currentServices"),
				() => fiberRefUnsafeMakeContext(liveServices),
			),
			clockWith = f =>
				fiberRefGetWith(currentServices, services =>
					f(Context_get(services, clockTag)),
				),
			currentTimeMillis = clockWith(clock => clock.currentTimeMillis),
			Boolean_Order = Order_boolean,
			Effectable_EffectTypeId = EffectTypeId,
			executionStrategy_sequential = { _tag: "Sequential" },
			ExecutionStrategy_sequential = executionStrategy_sequential,
			ExecutionStrategy_parallel = { _tag: "Parallel" },
			ExecutionStrategy_parallelN = parallelism => ({
				_tag: "ParallelN",
				parallelism,
			}),
			FiberRefsSym = Symbol.for("effect/FiberRefs")
		class FiberRefsImpl {
			locals;
			[FiberRefsSym] = FiberRefsSym
			constructor(locals) {
				this.locals = locals
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const joinAs = Function_dual(3, (self, fiberId, that) => {
				const parentFiberRefs = new Map(self.locals)
				that.locals.forEach((childStack, fiberRef) => {
					const childValue = childStack[0][1]
					if (!childStack[0][0][Equal_symbol](fiberId)) {
						if (!parentFiberRefs.has(fiberRef)) {
							if (equals(childValue, fiberRef.initial)) return
							parentFiberRefs.set(fiberRef, [
								[fiberId, fiberRef.join(fiberRef.initial, childValue)],
							])
							return
						}
						const parentStack = parentFiberRefs.get(fiberRef),
							[ancestor, wasModified] = ((
								_ref,
								_parentStack,
								_childStack,
								_childModified = !1,
							) => {
								const ref = _ref
								let ret,
									parentStack = _parentStack,
									childStack = _childStack,
									childModified = _childModified
								for (; void 0 === ret; )
									if (
										isNonEmptyReadonlyArray(parentStack) &&
										isNonEmptyReadonlyArray(childStack)
									) {
										const parentFiberId = headNonEmpty(parentStack)[0],
											parentAncestors = tailNonEmpty(parentStack),
											childFiberId = headNonEmpty(childStack)[0],
											childRefValue = headNonEmpty(childStack)[1],
											childAncestors = tailNonEmpty(childStack)
										if (
											parentFiberId.startTimeMillis <
											childFiberId.startTimeMillis
										) {
											childStack = childAncestors
											childModified = !0
										} else if (
											parentFiberId.startTimeMillis >
											childFiberId.startTimeMillis
										)
											parentStack = parentAncestors
										else if (parentFiberId.id < childFiberId.id) {
											childStack = childAncestors
											childModified = !0
										} else
											parentFiberId.id > childFiberId.id
												? (parentStack = parentAncestors)
												: (ret = [childRefValue, childModified])
									} else ret = [ref.initial, !0]
								return ret
							})(fiberRef, parentStack, childStack)
						if (wasModified) {
							const patch = fiberRef.diff(ancestor, childValue),
								oldValue = parentStack[0][1],
								newValue = fiberRef.join(
									oldValue,
									fiberRef.patch(patch)(oldValue),
								)
							if (!equals(oldValue, newValue)) {
								let newStack
								const parentFiberId = parentStack[0][0]
								newStack = parentFiberId[Equal_symbol](fiberId)
									? [[parentFiberId, newValue], ...parentStack.slice(1)]
									: [[fiberId, newValue], ...parentStack]
								parentFiberRefs.set(fiberRef, newStack)
							}
						}
					}
				})
				return new FiberRefsImpl(parentFiberRefs)
			}),
			forkAs = Function_dual(2, (self, childId) => {
				const map = new Map()
				unsafeForkAs(self, map, childId)
				return new FiberRefsImpl(map)
			}),
			unsafeForkAs = (self, map, fiberId) => {
				self.locals.forEach((stack, fiberRef) => {
					const oldValue = stack[0][1],
						newValue = fiberRef.patch(fiberRef.fork)(oldValue)
					equals(oldValue, newValue)
						? map.set(fiberRef, stack)
						: map.set(fiberRef, [[fiberId, newValue], ...stack])
				})
			},
			delete_ = Function_dual(2, (self, fiberRef) => {
				const locals = new Map(self.locals)
				locals.delete(fiberRef)
				return new FiberRefsImpl(locals)
			}),
			fiberRefs_get = Function_dual(2, (self, fiberRef) =>
				self.locals.has(fiberRef)
					? Option_some(headNonEmpty(self.locals.get(fiberRef))[1])
					: Option_none(),
			),
			getOrDefault = Function_dual(2, (self, fiberRef) =>
				Function_pipe(
					fiberRefs_get(self, fiberRef),
					getOrElse(() => fiberRef.initial),
				),
			),
			updateAs = Function_dual(2, (self, { fiberId, fiberRef, value }) => {
				if (0 === self.locals.size)
					return new FiberRefsImpl(new Map([[fiberRef, [[fiberId, value]]]]))
				const locals = new Map(self.locals)
				unsafeUpdateAs(locals, fiberId, fiberRef, value)
				return new FiberRefsImpl(locals)
			}),
			unsafeUpdateAs = (locals, fiberId, fiberRef, value) => {
				const oldStack = locals.get(fiberRef) ?? []
				let newStack
				if (isNonEmptyReadonlyArray(oldStack)) {
					const [currentId, currentValue] = headNonEmpty(oldStack)
					if (currentId[Equal_symbol](fiberId)) {
						if (equals(currentValue, value)) return
						newStack = [[fiberId, value], ...oldStack.slice(1)]
					} else newStack = [[fiberId, value], ...oldStack]
				} else newStack = [[fiberId, value]]
				locals.set(fiberRef, newStack)
			},
			updateManyAs = Function_dual(2, (self, { entries, forkAs }) => {
				if (0 === self.locals.size) return new FiberRefsImpl(new Map(entries))
				const locals = new Map(self.locals)
				void 0 !== forkAs && unsafeForkAs(self, locals, forkAs)
				entries.forEach(([fiberRef, values]) => {
					1 === values.length
						? unsafeUpdateAs(locals, values[0][0], fiberRef, values[0][1])
						: values.forEach(([fiberId, value]) => {
								unsafeUpdateAs(locals, fiberId, fiberRef, value)
							})
				})
				return new FiberRefsImpl(locals)
			}),
			FiberRefs_getOrDefault = getOrDefault,
			FiberRefs_updateManyAs = updateManyAs,
			FiberRefs_empty = function () {
				return (fiberRefLocals = new Map()), new FiberRefsImpl(fiberRefLocals)
				var fiberRefLocals
			},
			patch_empty = { _tag: "Empty" },
			patch_diff = (oldValue, newValue) => {
				const missingLocals = new Map(oldValue.locals)
				let patch = patch_empty
				for (const [fiberRef, pairs] of newValue.locals.entries()) {
					const newValue = headNonEmpty(pairs)[1],
						old = missingLocals.get(fiberRef)
					if (void 0 !== old) {
						const oldValue = headNonEmpty(old)[1]
						equals(oldValue, newValue) ||
							(patch = patch_combine({
								_tag: "Update",
								fiberRef,
								patch: fiberRef.diff(oldValue, newValue),
							})(patch))
					} else
						patch = patch_combine({ _tag: "Add", fiberRef, value: newValue })(
							patch,
						)
					missingLocals.delete(fiberRef)
				}
				for (const [fiberRef] of missingLocals.entries())
					patch = patch_combine({ _tag: "Remove", fiberRef })(patch)
				return patch
			},
			patch_combine = Function_dual(2, (self, that) => ({
				_tag: "AndThen",
				first: self,
				second: that,
			})),
			patch_patch = Function_dual(3, (self, fiberId, oldValue) => {
				let fiberRefs = oldValue,
					patches = Array_of(self)
				for (; isNonEmptyReadonlyArray(patches); ) {
					const head = headNonEmpty(patches),
						tail = tailNonEmpty(patches)
					switch (head._tag) {
						case "Empty":
							patches = tail
							break
						case "Add":
							fiberRefs = updateAs(fiberRefs, {
								fiberId,
								fiberRef: head.fiberRef,
								value: head.value,
							})
							patches = tail
							break
						case "Remove":
							fiberRefs = delete_(fiberRefs, head.fiberRef)
							patches = tail
							break
						case "Update": {
							const value = getOrDefault(fiberRefs, head.fiberRef)
							fiberRefs = updateAs(fiberRefs, {
								fiberId,
								fiberRef: head.fiberRef,
								value: head.fiberRef.patch(head.patch)(value),
							})
							patches = tail
							break
						}
						case "AndThen":
							patches = Array_prepend(head.first)(
								Array_prepend(head.second)(tail),
							)
					}
				}
				return fiberRefs
			}),
			FiberRefsPatch_diff = patch_diff,
			FiberRefsPatch_patch = patch_patch,
			FiberStatusTypeId = Symbol.for("effect/FiberStatus"),
			DoneHash = string("effect/FiberStatus-Done")
		class Done {
			[FiberStatusTypeId] = FiberStatusTypeId
			_tag = "Done";
			[symbol]() {
				return DoneHash
			}
			[Equal_symbol](that) {
				return isFiberStatus(that) && "Done" === that._tag
			}
		}
		class Running {
			runtimeFlags;
			[FiberStatusTypeId] = FiberStatusTypeId
			_tag = "Running"
			constructor(runtimeFlags) {
				this.runtimeFlags = runtimeFlags
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/FiberStatus"),
					combine(Hash_hash(this._tag)),
					combine(Hash_hash(this.runtimeFlags)),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return (
					isFiberStatus(that) &&
					"Running" === that._tag &&
					this.runtimeFlags === that.runtimeFlags
				)
			}
		}
		class Suspended {
			runtimeFlags
			blockingOn;
			[FiberStatusTypeId] = FiberStatusTypeId
			_tag = "Suspended"
			constructor(runtimeFlags, blockingOn) {
				this.runtimeFlags = runtimeFlags
				this.blockingOn = blockingOn
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/FiberStatus"),
					combine(Hash_hash(this._tag)),
					combine(Hash_hash(this.runtimeFlags)),
					combine(Hash_hash(this.blockingOn)),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return (
					isFiberStatus(that) &&
					"Suspended" === that._tag &&
					this.runtimeFlags === that.runtimeFlags &&
					equals(this.blockingOn, that.blockingOn)
				)
			}
		}
		const isFiberStatus = u => Predicate_hasProperty(u, FiberStatusTypeId),
			FiberStatus_done = new Done(),
			FiberStatus_running = runtimeFlags => new Running(runtimeFlags),
			Fatal = logLevelFatal,
			LogLevel_Error = logLevelError,
			Warning = logLevelWarning,
			Info = logLevelInfo,
			Debug = logLevelDebug,
			Trace = logLevelTrace,
			locally = Function_dual(2, (use, self) =>
				fiberRefLocally(use, currentLogLevel, self),
			),
			LogLevel_Order = Function_pipe(
				Number_Order,
				Order_mapInput(level => level.ordinal),
			),
			LogLevel_greaterThan = greaterThan(LogLevel_Order),
			greaterThanEqual = greaterThanOrEqualTo(LogLevel_Order),
			runSymbol = Symbol.for("effect/Micro/runSymbol")
		globalThis.Error
		const EnvTypeId = Symbol.for("effect/Micro/Env"),
			EnvRefTypeId = Symbol.for("effect/Micro/EnvRef"),
			EnvProto = {
				[EnvTypeId]: { _R: Function_identity },
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			envMake = refs => {
				const self = Object.create(EnvProto)
				self.refs = refs
				return self
			},
			envGet = Function_dual(2, (self, ref) =>
				ref.key in self.refs ? self.refs[ref.key] : ref.initial,
			),
			envSet = Function_dual(3, (self, ref, value) => {
				const refs = Object.assign(Object.create(null), self.refs)
				refs[ref.key] = value
				return envMake(refs)
			}),
			EnvRefProto = { [EnvRefTypeId]: EnvRefTypeId },
			envRefMake = (key, initial) =>
				globalValue(key, () => {
					const self = Object.create(EnvRefProto)
					self.key = key
					self.initial = initial()
					return self
				}),
			currentAbortController = envRefMake(
				"effect/Micro/currentAbortController",
				() => {},
			),
			currentAbortSignal = envRefMake(
				"effect/Micro/currentAbortSignal",
				() => {},
			),
			Micro_currentContext = envRefMake("effect/Micro/currentContext", () =>
				Context_empty(),
			)
		Symbol.iterator, "setImmediate" in globalThis && globalThis.setImmediate
		const Readable_TypeId = Symbol.for("effect/Readable"),
			RefTypeId = Symbol.for("effect/Ref"),
			refVariance = { _A: _ => _ }
		class RefImpl {
			ref;
			[RefTypeId] = refVariance;
			[Readable_TypeId]
			constructor(ref) {
				this.ref = ref
				this[Readable_TypeId] = Readable_TypeId
				this.get = sync(() => MutableRef_get(this.ref))
			}
			get;
			modify(f) {
				return sync(() => {
					const current = MutableRef_get(this.ref),
						[b, a] = f(current)
					current !== a && MutableRef_set(a)(this.ref)
					return b
				})
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const ref_unsafeMake = value => new RefImpl(MutableRef_make(value)),
			ref_make = value => sync(() => ref_unsafeMake(value)),
			ref_get = self => self.get,
			ref_set = Function_dual(2, (self, value) =>
				self.modify(() => [void 0, value]),
			),
			ref_modify = Function_dual(2, (self, f) => self.modify(f)),
			ref_update = Function_dual(2, (self, f) =>
				self.modify(a => [void 0, f(a)]),
			)
		class PriorityBuckets {
			buckets = []
			scheduleTask(task, priority) {
				let bucket, index
				for (
					index = 0;
					index < this.buckets.length && this.buckets[index][0] <= priority;
					index++
				)
					bucket = this.buckets[index]
				if (bucket) bucket[1].push(task)
				else {
					const newBuckets = []
					for (let i = 0; i < index; i++) newBuckets.push(this.buckets[i])
					newBuckets.push([priority, [task]])
					for (let i = index; i < this.buckets.length; i++)
						newBuckets.push(this.buckets[i])
					this.buckets = newBuckets
				}
			}
		}
		class MixedScheduler {
			maxNextTickBeforeTimer
			running = !1
			tasks = new PriorityBuckets()
			constructor(maxNextTickBeforeTimer) {
				this.maxNextTickBeforeTimer = maxNextTickBeforeTimer
			}
			starveInternal(depth) {
				const tasks = this.tasks.buckets
				this.tasks.buckets = []
				for (const [_, toRun] of tasks)
					for (let i = 0; i < toRun.length; i++) toRun[i]()
				0 === this.tasks.buckets.length
					? (this.running = !1)
					: this.starve(depth)
			}
			starve(depth = 0) {
				depth >= this.maxNextTickBeforeTimer
					? setTimeout(() => this.starveInternal(0), 0)
					: Promise.resolve(void 0).then(() => this.starveInternal(depth + 1))
			}
			shouldYield(fiber) {
				return (
					fiber.currentOpCount > fiber.getFiberRef(currentMaxOpsBeforeYield) &&
					fiber.getFiberRef(currentSchedulingPriority)
				)
			}
			scheduleTask(task, priority) {
				this.tasks.scheduleTask(task, priority)
				if (!this.running) {
					this.running = !0
					this.starve()
				}
			}
		}
		const defaultScheduler = globalValue(
			Symbol.for("effect/Scheduler/defaultScheduler"),
			() => new MixedScheduler(2048),
		)
		class SyncScheduler {
			tasks = new PriorityBuckets()
			deferred = !1
			scheduleTask(task, priority) {
				this.deferred
					? defaultScheduler.scheduleTask(task, priority)
					: this.tasks.scheduleTask(task, priority)
			}
			shouldYield(fiber) {
				return (
					fiber.currentOpCount > fiber.getFiberRef(currentMaxOpsBeforeYield) &&
					fiber.getFiberRef(currentSchedulingPriority)
				)
			}
			flush() {
				for (; this.tasks.buckets.length > 0; ) {
					const tasks = this.tasks.buckets
					this.tasks.buckets = []
					for (const [_, toRun] of tasks)
						for (let i = 0; i < toRun.length; i++) toRun[i]()
				}
				this.deferred = !0
			}
		}
		const currentScheduler = globalValue(
				Symbol.for("effect/FiberRef/currentScheduler"),
				() => fiberRefUnsafeMake(defaultScheduler),
			),
			par = (self, that) => ({ _tag: "Par", left: self, right: that }),
			seq = (self, that) => ({ _tag: "Seq", left: self, right: that }),
			blockedRequests_step = requests => {
				let current = requests,
					parallel = parallelCollectionEmpty(),
					stack = List_empty(),
					sequential = List_empty()
				for (;;)
					switch (current._tag) {
						case "Empty":
							if (isNil(stack)) return [parallel, sequential]
							current = stack.head
							stack = stack.tail
							break
						case "Par":
							stack = cons(current.right, stack)
							current = current.left
							break
						case "Seq": {
							const left = current.left,
								right = current.right
							switch (left._tag) {
								case "Empty":
									current = right
									break
								case "Par": {
									const l = left.left,
										r = left.right
									current = par(seq(l, right), seq(r, right))
									break
								}
								case "Seq": {
									const l = left.left,
										r = left.right
									current = seq(l, seq(r, right))
									break
								}
								case "Single":
									current = left
									sequential = cons(right, sequential)
							}
							break
						}
						case "Single":
							parallel = parallelCollectionAdd(parallel, current)
							if (isNil(stack)) return [parallel, sequential]
							current = stack.head
							stack = stack.tail
					}
				throw new Error(
					"BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/effect/issues",
				)
			},
			blockedRequests_merge = (sequential, parallel) => {
				if (isNil(sequential))
					return List_of(parallelCollectionToSequentialCollection(parallel))
				if (parallelCollectionIsEmpty(parallel)) return sequential
				const seqHeadKeys = sequentialCollectionKeys(sequential.head),
					parKeys = parallelCollectionKeys(parallel)
				return 1 === seqHeadKeys.length &&
					1 === parKeys.length &&
					equals(seqHeadKeys[0], parKeys[0])
					? cons(
							sequentialCollectionCombine(
								sequential.head,
								parallelCollectionToSequentialCollection(parallel),
							),
							sequential.tail,
						)
					: cons(parallelCollectionToSequentialCollection(parallel), sequential)
			},
			RequestBlockParallelTypeId = Symbol.for(
				"effect/RequestBlock/RequestBlockParallel",
			),
			parallelVariance = { _R: _ => _ }
		class ParallelImpl {
			map;
			[RequestBlockParallelTypeId] = parallelVariance
			constructor(map) {
				this.map = map
			}
		}
		const parallelCollectionEmpty = () => new ParallelImpl(HashMap_empty()),
			parallelCollectionAdd = (self, blockedRequest) =>
				new ParallelImpl(
					HashMap_modifyAt(self.map, blockedRequest.dataSource, _ =>
						orElseSome(
							map(_, Chunk_append(blockedRequest.blockedRequest)),
							() => Chunk_of(blockedRequest.blockedRequest),
						),
					),
				),
			parallelCollectionCombine = (self, that) =>
				new ParallelImpl(
					HashMap_reduce(self.map, that.map, (map, value, key) =>
						HashMap_set(
							map,
							key,
							match(HashMap_get(map, key), {
								onNone: () => value,
								onSome: other => Chunk_appendAll(value, other),
							}),
						),
					),
				),
			parallelCollectionIsEmpty = self =>
				(self => self && isEmptyNode(self._root))(self.map),
			parallelCollectionKeys = self => Array.from(HashMap_keys(self.map)),
			parallelCollectionToSequentialCollection = self =>
				sequentialCollectionMake(HashMap_map(self.map, x => Chunk_of(x))),
			SequentialCollectionTypeId = Symbol.for(
				"effect/RequestBlock/RequestBlockSequential",
			),
			sequentialVariance = { _R: _ => _ }
		class SequentialImpl {
			map;
			[SequentialCollectionTypeId] = sequentialVariance
			constructor(map) {
				this.map = map
			}
		}
		const sequentialCollectionMake = map => new SequentialImpl(map),
			sequentialCollectionCombine = (self, that) =>
				new SequentialImpl(
					HashMap_reduce(that.map, self.map, (map, value, key) =>
						HashMap_set(
							map,
							key,
							match(HashMap_get(map, key), {
								onNone: () => esm_Chunk_empty(),
								onSome: a => Chunk_appendAll(a, value),
							}),
						),
					),
				),
			sequentialCollectionKeys = self => Array.from(HashMap_keys(self.map)),
			currentRequestMap = globalValue(
				Symbol.for("effect/FiberRef/currentRequestMap"),
				() => fiberRefUnsafeMake(new Map()),
			),
			concurrency_match = (concurrency, sequential, unbounded, bounded) => {
				switch (concurrency) {
					case void 0:
						return sequential()
					case "unbounded":
						return unbounded()
					case "inherit":
						return fiberRefGetWith(currentConcurrency, concurrency =>
							"unbounded" === concurrency
								? unbounded()
								: concurrency > 1
									? bounded(concurrency)
									: sequential(),
						)
					default:
						return concurrency > 1 ? bounded(concurrency) : sequential()
				}
			},
			Clock_currentTimeMillis = currentTimeMillis,
			LogSpan_render = now => self =>
				`${self.label.replace(/[\s="]/g, "_")}=${now - self.startTime}ms`,
			MetricLabelTypeId = Symbol.for("effect/MetricLabel")
		class MetricLabelImpl {
			key
			value;
			[MetricLabelTypeId] = MetricLabelTypeId
			_hash
			constructor(key, value) {
				this.key = key
				this.value = value
				this._hash = string("effect/MetricLabel" + this.key + this.value)
			}
			[symbol]() {
				return this._hash
			}
			[Equal_symbol](that) {
				return (
					isMetricLabel(that) &&
					this.key === that.key &&
					this.value === that.value
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const label_make = (key, value) => new MetricLabelImpl(key, value),
			isMetricLabel = u => Predicate_hasProperty(u, MetricLabelTypeId),
			annotateLogs = Function_dual(
				args => isEffect(args[0]),
				function () {
					const args = arguments
					return fiberRefLocallyWith(
						args[0],
						currentLogAnnotations,
						"string" == typeof args[1]
							? HashMap_set(args[1], args[2])
							: annotations =>
									Object.entries(args[1]).reduce(
										(acc, [key, value]) => HashMap_set(acc, key, value),
										annotations,
									),
					)
				},
			),
			filterOrElse = Function_dual(3, (self, predicate, orElse) =>
				core_flatMap(self, a => (predicate(a) ? succeed(a) : orElse(a))),
			),
			core_effect_filterOrFail = Function_dual(
				args => isEffect(args[0]),
				(self, predicate, orFailWith) =>
					filterOrElse(self, predicate, a =>
						void 0 === orFailWith
							? core_fail(new NoSuchElementException())
							: failSync(() => orFailWith(a)),
					),
			),
			core_effect_match = Function_dual(2, (self, options) =>
				matchEffect(self, {
					onFailure: e => succeed(options.onFailure(e)),
					onSuccess: a => succeed(options.onSuccess(a)),
				}),
			),
			core_effect_fiberRefs = withFiberRuntime(state =>
				succeed(state.getFiberRefs()),
			),
			logWithLevel =
				level =>
				(...message) => {
					const levelOption = fromNullable(level)
					let cause
					for (let i = 0, len = message.length; i < len; i++) {
						const msg = message[i]
						if (isCause(msg)) {
							cause = void 0 !== cause ? sequential(cause, msg) : msg
							message = [...message.slice(0, i), ...message.slice(i + 1)]
							i--
						}
					}
					void 0 === cause && (cause = cause_empty)
					return withFiberRuntime(fiberState => {
						fiberState.log(message, cause, levelOption)
						return core_void_
					})
				},
			log = logWithLevel(),
			logDebug = logWithLevel(Debug),
			logInfo = logWithLevel(Info),
			logWarning = logWithLevel(Warning),
			logError = logWithLevel(LogLevel_Error),
			core_effect_orElseSucceed = Function_dual(2, (self, evaluate) =>
				core_orElse(self, () => sync(evaluate)),
			),
			summarized = Function_dual(3, (self, summary, f) =>
				core_flatMap(summary, start =>
					core_flatMap(self, value =>
						core_map(summary, end => [f(start, end), value]),
					),
				),
			),
			core_effect_tapErrorCause = Function_dual(2, (self, f) =>
				matchCauseEffect(self, {
					onFailure: cause => core_zipRight(f(cause), failCause(cause)),
					onSuccess: succeed,
				}),
			),
			core_effect_when = Function_dual(2, (self, condition) =>
				suspend(() =>
					condition() ? core_map(self, Option_some) : succeed(Option_none()),
				),
			),
			interruptSignal = cause => ({ _tag: "InterruptSignal", cause }),
			stateful = onFiber => ({ _tag: "Stateful", onFiber }),
			resume = effect => ({ _tag: "Resume", effect }),
			FiberScopeTypeId = Symbol.for("effect/FiberScope")
		class Global {
			[FiberScopeTypeId] = FiberScopeTypeId
			fiberId = FiberId_none
			roots = new Set()
			add(_runtimeFlags, child) {
				this.roots.add(child)
				child.addObserver(() => {
					this.roots.delete(child)
				})
			}
		}
		class Local {
			fiberId
			parent;
			[FiberScopeTypeId] = FiberScopeTypeId
			constructor(fiberId, parent) {
				this.fiberId = fiberId
				this.parent = parent
			}
			add(_runtimeFlags, child) {
				this.parent.tell(
					stateful(parentFiber => {
						parentFiber.addChild(child)
						child.addObserver(() => {
							parentFiber.removeChild(child)
						})
					}),
				)
			}
		}
		const globalScope = globalValue(
				Symbol.for("effect/FiberScope/Global"),
				() => new Global(),
			),
			FiberTypeId = Symbol.for("effect/Fiber"),
			fiberVariance = { _E: _ => _, _A: _ => _ },
			RuntimeFiberTypeId = Symbol.for("effect/Fiber"),
			currentFiberURI = "effect/FiberCurrent",
			LoggerTypeId = Symbol.for("effect/Logger"),
			loggerVariance = { _Message: _ => _, _Output: _ => _ },
			makeLogger = log => ({
				[LoggerTypeId]: loggerVariance,
				log,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			}),
			logger_zip = Function_dual(2, (self, that) =>
				makeLogger(options => [self.log(options), that.log(options)]),
			),
			stringLogger = makeLogger(
				({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
					const nowMillis = date.getTime()
					let output = [
						`timestamp=${date.toISOString()}`,
						`level=${logLevel.label}`,
						`fiber=${threadName(fiberId)}`,
					].join(" ")
					const messageArr = (self => (Array.isArray(self) ? self : [self]))(
						message,
					)
					for (let i = 0; i < messageArr.length; i++) {
						const stringMessage = toStringUnknown(messageArr[i])
						if (stringMessage.length > 0) {
							output += " message="
							output = appendQuoted(stringMessage, output)
						}
					}
					if (null != cause && "Empty" !== cause._tag) {
						output += " cause="
						output = appendQuoted(
							pretty(cause, { renderErrorCause: !0 }),
							output,
						)
					}
					if (isCons(spans)) {
						output += " "
						let first = !0
						for (const span of spans) {
							first ? (first = !1) : (output += " ")
							output += Function_pipe(span, LogSpan_render(nowMillis))
						}
					}
					if (HashMap_size(annotations) > 0) {
						output += " "
						let first = !0
						for (const [key, value] of annotations) {
							first ? (first = !1) : (output += " ")
							output += filterKeyName(key)
							output += "="
							output = appendQuoted(toStringUnknown(value), output)
						}
					}
					return output
				},
			),
			textOnly = /^[^\s"=]+$/,
			appendQuoted = (label, output) =>
				output +
				(label.match(textOnly)
					? label
					: `"${label.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`),
			filterKeyName = key => key.replace(/[\s="]/g, "_"),
			MetricKeyTypeTypeId =
				("object" == typeof process &&
					null !== process &&
					"object" == typeof process.stdout &&
					null !== process.stdout &&
					process.stdout.isTTY,
				"object" == typeof self && null !== self && self.constructor,
				Symbol.for("effect/MetricKeyType")),
			CounterKeyTypeTypeId = Symbol.for("effect/MetricKeyType/Counter"),
			FrequencyKeyTypeTypeId = Symbol.for("effect/MetricKeyType/Frequency"),
			GaugeKeyTypeTypeId = Symbol.for("effect/MetricKeyType/Gauge"),
			HistogramKeyTypeTypeId = Symbol.for("effect/MetricKeyType/Histogram"),
			SummaryKeyTypeTypeId = Symbol.for("effect/MetricKeyType/Summary"),
			metricKeyTypeVariance = { _In: _ => _, _Out: _ => _ }
		class CounterKeyType {
			incremental
			bigint;
			[MetricKeyTypeTypeId] = metricKeyTypeVariance;
			[CounterKeyTypeTypeId] = CounterKeyTypeTypeId
			constructor(incremental, bigint) {
				this.incremental = incremental
				this.bigint = bigint
				this._hash = string("effect/MetricKeyType/Counter")
			}
			_hash;
			[symbol]() {
				return this._hash
			}
			[Equal_symbol](that) {
				return isCounterKey(that)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		class HistogramKeyType {
			boundaries;
			[MetricKeyTypeTypeId] = metricKeyTypeVariance;
			[HistogramKeyTypeTypeId] = HistogramKeyTypeTypeId
			constructor(boundaries) {
				this.boundaries = boundaries
				this._hash = Function_pipe(
					string("effect/MetricKeyType/Histogram"),
					combine(Hash_hash(this.boundaries)),
				)
			}
			_hash;
			[symbol]() {
				return this._hash
			}
			[Equal_symbol](that) {
				return isHistogramKey(that) && equals(this.boundaries, that.boundaries)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const isCounterKey = u => Predicate_hasProperty(u, CounterKeyTypeTypeId),
			isHistogramKey = u => Predicate_hasProperty(u, HistogramKeyTypeTypeId),
			MetricKeyTypeId = Symbol.for("effect/MetricKey"),
			metricKeyVariance = { _Type: _ => _ },
			arrayEquivilence = Array_getEquivalence(equals)
		class MetricKeyImpl {
			name
			keyType
			description
			tags;
			[MetricKeyTypeId] = metricKeyVariance
			constructor(name, keyType, description, tags = []) {
				this.name = name
				this.keyType = keyType
				this.description = description
				this.tags = tags
				this._hash = Function_pipe(
					string(this.name + this.description),
					combine(Hash_hash(this.keyType)),
					combine(array(this.tags)),
				)
			}
			_hash;
			[symbol]() {
				return this._hash
			}
			[Equal_symbol](u) {
				return (
					isMetricKey(u) &&
					this.name === u.name &&
					equals(this.keyType, u.keyType) &&
					equals(this.description, u.description) &&
					arrayEquivilence(this.tags, u.tags)
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const isMetricKey = u => Predicate_hasProperty(u, MetricKeyTypeId),
			taggedWithLabels = Function_dual(2, (self, extraTags) =>
				0 === extraTags.length
					? self
					: new MetricKeyImpl(
							self.name,
							self.keyType,
							self.description,
							Array_union(self.tags, extraTags),
						),
			),
			MutableHashMap_TypeId = Symbol.for("effect/MutableHashMap"),
			MutableHashMapProto = {
				[MutableHashMap_TypeId]: MutableHashMap_TypeId,
				[Symbol.iterator]() {
					return new MutableHashMapIterator(this)
				},
				toString() {
					return format(this.toJSON())
				},
				toJSON() {
					return { _id: "MutableHashMap", values: Array.from(this).map(toJSON) }
				},
				[Inspectable_NodeInspectSymbol]() {
					return this.toJSON()
				},
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			}
		class MutableHashMapIterator {
			self
			referentialIterator
			bucketIterator
			constructor(self) {
				this.self = self
				this.referentialIterator = self.referential[Symbol.iterator]()
			}
			next() {
				if (void 0 !== this.bucketIterator) return this.bucketIterator.next()
				const result = this.referentialIterator.next()
				if (result.done) {
					this.bucketIterator = new BucketIterator(this.self.buckets.values())
					return this.next()
				}
				return result
			}
			[Symbol.iterator]() {
				return new MutableHashMapIterator(this.self)
			}
		}
		class BucketIterator {
			backing
			constructor(backing) {
				this.backing = backing
			}
			currentBucket
			next() {
				if (void 0 === this.currentBucket) {
					const result = this.backing.next()
					if (result.done) return result
					this.currentBucket = result.value[Symbol.iterator]()
				}
				const result = this.currentBucket.next()
				if (result.done) {
					this.currentBucket = void 0
					return this.next()
				}
				return result
			}
		}
		const MutableHashMap_empty = () => {
				const self = Object.create(MutableHashMapProto)
				self.referential = new Map()
				self.buckets = new Map()
				self.bucketsSize = 0
				return self
			},
			MutableHashMap_get = Function_dual(2, (self, key) => {
				if (!1 === isEqual(key))
					return self.referential.has(key)
						? Option_some(self.referential.get(key))
						: Option_none()
				const hash = key[symbol](),
					bucket = self.buckets.get(hash)
				return void 0 === bucket
					? Option_none()
					: getFromBucket(self, bucket, key)
			}),
			getFromBucket = (self, bucket, key, remove = !1) => {
				for (let i = 0, len = bucket.length; i < len; i++)
					if (key[Equal_symbol](bucket[i][0])) {
						const value = bucket[i][1]
						if (remove) {
							bucket.splice(i, 1)
							self.bucketsSize--
						}
						return Option_some(value)
					}
				return Option_none()
			},
			MutableHashMap_has = Function_dual(2, (self, key) =>
				Option_isSome(MutableHashMap_get(self, key)),
			),
			MutableHashMap_set = Function_dual(3, (self, key, value) => {
				if (!1 === isEqual(key)) {
					self.referential.set(key, value)
					return self
				}
				const hash = key[symbol](),
					bucket = self.buckets.get(hash)
				if (void 0 === bucket) {
					self.buckets.set(hash, [[key, value]])
					self.bucketsSize++
					return self
				}
				removeFromBucket(self, bucket, key)
				bucket.push([key, value])
				self.bucketsSize++
				return self
			}),
			removeFromBucket = (self, bucket, key) => {
				for (let i = 0, len = bucket.length; i < len; i++)
					if (key[Equal_symbol](bucket[i][0])) {
						bucket.splice(i, 1)
						self.bucketsSize--
						return
					}
			},
			MetricStateTypeId = Symbol.for("effect/MetricState"),
			CounterStateTypeId = Symbol.for("effect/MetricState/Counter"),
			FrequencyStateTypeId = Symbol.for("effect/MetricState/Frequency"),
			GaugeStateTypeId = Symbol.for("effect/MetricState/Gauge"),
			HistogramStateTypeId = Symbol.for("effect/MetricState/Histogram"),
			SummaryStateTypeId = Symbol.for("effect/MetricState/Summary"),
			metricStateVariance = { _A: _ => _ }
		class CounterState {
			count;
			[MetricStateTypeId] = metricStateVariance;
			[CounterStateTypeId] = CounterStateTypeId
			constructor(count) {
				this.count = count
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/MetricState/Counter"),
					combine(Hash_hash(this.count)),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return isCounterState(that) && this.count === that.count
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const arrayEquals = Array_getEquivalence(equals)
		class FrequencyState {
			occurrences;
			[MetricStateTypeId] = metricStateVariance;
			[FrequencyStateTypeId] = FrequencyStateTypeId
			constructor(occurrences) {
				this.occurrences = occurrences
			}
			_hash;
			[symbol]() {
				return Function_pipe(
					string("effect/MetricState/Frequency"),
					combine(array(Array_fromIterable(this.occurrences.entries()))),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return (
					isFrequencyState(that) &&
					arrayEquals(
						Array_fromIterable(this.occurrences.entries()),
						Array_fromIterable(that.occurrences.entries()),
					)
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		class GaugeState {
			value;
			[MetricStateTypeId] = metricStateVariance;
			[GaugeStateTypeId] = GaugeStateTypeId
			constructor(value) {
				this.value = value
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/MetricState/Gauge"),
					combine(Hash_hash(this.value)),
					cached(this),
				)
			}
			[Equal_symbol](u) {
				return isGaugeState(u) && this.value === u.value
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		class HistogramState {
			buckets
			count
			min
			max
			sum;
			[MetricStateTypeId] = metricStateVariance;
			[HistogramStateTypeId] = HistogramStateTypeId
			constructor(buckets, count, min, max, sum) {
				this.buckets = buckets
				this.count = count
				this.min = min
				this.max = max
				this.sum = sum
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/MetricState/Histogram"),
					combine(Hash_hash(this.buckets)),
					combine(Hash_hash(this.count)),
					combine(Hash_hash(this.min)),
					combine(Hash_hash(this.max)),
					combine(Hash_hash(this.sum)),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return (
					isHistogramState(that) &&
					equals(this.buckets, that.buckets) &&
					this.count === that.count &&
					this.min === that.min &&
					this.max === that.max &&
					this.sum === that.sum
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		class SummaryState {
			error
			quantiles
			count
			min
			max
			sum;
			[MetricStateTypeId] = metricStateVariance;
			[SummaryStateTypeId] = SummaryStateTypeId
			constructor(error, quantiles, count, min, max, sum) {
				this.error = error
				this.quantiles = quantiles
				this.count = count
				this.min = min
				this.max = max
				this.sum = sum
			}
			[symbol]() {
				return Function_pipe(
					Hash_hash("effect/MetricState/Summary"),
					combine(Hash_hash(this.error)),
					combine(Hash_hash(this.quantiles)),
					combine(Hash_hash(this.count)),
					combine(Hash_hash(this.min)),
					combine(Hash_hash(this.max)),
					combine(Hash_hash(this.sum)),
					cached(this),
				)
			}
			[Equal_symbol](that) {
				return (
					isSummaryState(that) &&
					this.error === that.error &&
					equals(this.quantiles, that.quantiles) &&
					this.count === that.count &&
					this.min === that.min &&
					this.max === that.max &&
					this.sum === that.sum
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const isCounterState = u => Predicate_hasProperty(u, CounterStateTypeId),
			isFrequencyState = u => Predicate_hasProperty(u, FrequencyStateTypeId),
			isGaugeState = u => Predicate_hasProperty(u, GaugeStateTypeId),
			isHistogramState = u => Predicate_hasProperty(u, HistogramStateTypeId),
			isSummaryState = u => Predicate_hasProperty(u, SummaryStateTypeId),
			MetricHookTypeId = Symbol.for("effect/MetricHook"),
			metricHookVariance = { _In: _ => _, _Out: _ => _ },
			hook_make = options => ({
				[MetricHookTypeId]: metricHookVariance,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
				...options,
			}),
			hook_bigint0 = BigInt(0),
			resolveQuantile = (
				error,
				sampleCount,
				current,
				consumed,
				quantile,
				rest,
			) => {
				let error_1 = error,
					sampleCount_1 = sampleCount,
					current_1 = current,
					consumed_1 = consumed,
					quantile_1 = quantile,
					rest_1 = rest,
					error_2 = error,
					sampleCount_2 = sampleCount,
					current_2 = current,
					consumed_2 = consumed,
					quantile_2 = quantile,
					rest_2 = rest
				for (;;) {
					if (!isNonEmptyReadonlyArray(rest_1))
						return {
							quantile: quantile_1,
							value: Option_none(),
							consumed: consumed_1,
							rest: [],
						}
					if (1 === quantile_1)
						return {
							quantile: quantile_1,
							value: Option_some(lastNonEmpty(rest_1)),
							consumed: consumed_1 + rest_1.length,
							rest: [],
						}
					const sameHead = span(rest_1, n => n <= rest_1[0]),
						desired = quantile_1 * sampleCount_1,
						allowedError = (error_1 / 2) * desired,
						candConsumed = consumed_1 + sameHead[0].length,
						candError = Math.abs(candConsumed - desired)
					if (candConsumed < desired - allowedError) {
						error_2 = error_1
						sampleCount_2 = sampleCount_1
						current_2 = Array_head(rest_1)
						consumed_2 = candConsumed
						quantile_2 = quantile_1
						rest_2 = sameHead[1]
						error_1 = error_2
						sampleCount_1 = sampleCount_2
						current_1 = current_2
						consumed_1 = consumed_2
						quantile_1 = quantile_2
						rest_1 = rest_2
					} else {
						if (candConsumed > desired + allowedError)
							return {
								quantile: quantile_1,
								value: current_1,
								consumed: consumed_1,
								rest: rest_1,
							}
						switch (current_1._tag) {
							case "None":
								error_2 = error_1
								sampleCount_2 = sampleCount_1
								current_2 = Array_head(rest_1)
								consumed_2 = candConsumed
								quantile_2 = quantile_1
								rest_2 = sameHead[1]
								error_1 = error_2
								sampleCount_1 = sampleCount_2
								current_1 = current_2
								consumed_1 = consumed_2
								quantile_1 = quantile_2
								rest_1 = rest_2
								continue
							case "Some":
								if (candError < Math.abs(desired - current_1.value)) {
									error_2 = error_1
									sampleCount_2 = sampleCount_1
									current_2 = Array_head(rest_1)
									consumed_2 = candConsumed
									quantile_2 = quantile_1
									rest_2 = sameHead[1]
									error_1 = error_2
									sampleCount_1 = sampleCount_2
									current_1 = current_2
									consumed_1 = consumed_2
									quantile_1 = quantile_2
									rest_1 = rest_2
									continue
								}
								return {
									quantile: quantile_1,
									value: Option_some(current_1.value),
									consumed: consumed_1,
									rest: rest_1,
								}
						}
					}
				}
				throw new Error(
					"BUG: MetricHook.resolveQuantiles - please report an issue at https://github.com/Effect-TS/effect/issues",
				)
			},
			MetricPairTypeId = Symbol.for("effect/MetricPair"),
			metricPairVariance = { _Type: _ => _ },
			pair_unsafeMake = (metricKey, metricState) => ({
				[MetricPairTypeId]: metricPairVariance,
				metricKey,
				metricState,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			}),
			MetricRegistryTypeId = Symbol.for("effect/MetricRegistry")
		class MetricRegistryImpl {
			[MetricRegistryTypeId] = MetricRegistryTypeId
			map = MutableHashMap_empty()
			snapshot() {
				const result = []
				for (const [key, hook] of this.map)
					result.push(pair_unsafeMake(key, hook.get()))
				return result
			}
			get(key) {
				const hook = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == hook) {
					if (isCounterKey(key.keyType)) return this.getCounter(key)
					if ((u => Predicate_hasProperty(u, GaugeKeyTypeTypeId))(key.keyType))
						return this.getGauge(key)
					if (
						(u => Predicate_hasProperty(u, FrequencyKeyTypeTypeId))(key.keyType)
					)
						return this.getFrequency(key)
					if (isHistogramKey(key.keyType)) return this.getHistogram(key)
					if (
						(u => Predicate_hasProperty(u, SummaryKeyTypeTypeId))(key.keyType)
					)
						return this.getSummary(key)
					throw new Error(
						"BUG: MetricRegistry.get - unknown MetricKeyType - please report an issue at https://github.com/Effect-TS/effect/issues",
					)
				}
				return hook
			}
			getCounter(key) {
				let value = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == value) {
					const counter = (key => {
						let sum = key.keyType.bigint ? hook_bigint0 : 0
						const canUpdate = key.keyType.incremental
							? key.keyType.bigint
								? value => value >= hook_bigint0
								: value => value >= 0
							: _value => !0
						return hook_make({
							get: () => new CounterState(sum),
							update: value => {
								canUpdate(value) && (sum += value)
							},
						})
					})(key)
					Function_pipe(this.map, MutableHashMap_has(key)) ||
						Function_pipe(this.map, MutableHashMap_set(key, counter))
					value = counter
				}
				return value
			}
			getFrequency(key) {
				let value = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == value) {
					const frequency = (key => {
						const values = new Map()
						for (const word of key.keyType.preregisteredWords)
							values.set(word, 0)
						return hook_make({
							get: () => new FrequencyState(values),
							update: word => {
								const slotCount = values.get(word) ?? 0
								values.set(word, slotCount + 1)
							},
						})
					})(key)
					Function_pipe(this.map, MutableHashMap_has(key)) ||
						Function_pipe(this.map, MutableHashMap_set(key, frequency))
					value = frequency
				}
				return value
			}
			getGauge(key) {
				let value = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == value) {
					const gauge = ((_key, startAt) => {
						let value = startAt
						return hook_make({
							get: () => new GaugeState(value),
							update: v => {
								value = v
							},
						})
					})(0, key.keyType.bigint ? BigInt(0) : 0)
					Function_pipe(this.map, MutableHashMap_has(key)) ||
						Function_pipe(this.map, MutableHashMap_set(key, gauge))
					value = gauge
				}
				return value
			}
			getHistogram(key) {
				let value = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == value) {
					const histogram = (key => {
						const bounds = key.keyType.boundaries.values,
							size = bounds.length,
							values = new Uint32Array(size + 1),
							boundaries = new Float32Array(size)
						let count = 0,
							sum = 0,
							min = Number.MAX_VALUE,
							max = Number.MIN_VALUE
						Function_pipe(
							bounds,
							sort(Number_Order),
							Array_map((n, i) => {
								boundaries[i] = n
							}),
						)
						const getBuckets = () => {
							const builder = allocate(size)
							let cumulated = 0
							for (let i = 0; i < size; i++) {
								const boundary = boundaries[i]
								cumulated += values[i]
								builder[i] = [boundary, cumulated]
							}
							return builder
						}
						return hook_make({
							get: () => {
								return (
									(options = { buckets: getBuckets(), count, min, max, sum }),
									new HistogramState(
										options.buckets,
										options.count,
										options.min,
										options.max,
										options.sum,
									)
								)
								var options
							},
							update: value => {
								let from = 0,
									to = size
								for (; from !== to; ) {
									const mid = Math.floor(from + (to - from) / 2)
									value <= boundaries[mid] ? (to = mid) : (from = mid)
									to === from + 1 &&
										(value <= boundaries[from] ? (to = from) : (from = to))
								}
								values[from] = values[from] + 1
								count += 1
								sum += value
								value < min && (min = value)
								value > max && (max = value)
							},
						})
					})(key)
					Function_pipe(this.map, MutableHashMap_has(key)) ||
						Function_pipe(this.map, MutableHashMap_set(key, histogram))
					value = histogram
				}
				return value
			}
			getSummary(key) {
				let value = Function_pipe(
					this.map,
					MutableHashMap_get(key),
					getOrUndefined,
				)
				if (null == value) {
					const summary = (key => {
						const { error, maxAge, maxSize, quantiles } = key.keyType,
							sortedQuantiles = Function_pipe(quantiles, sort(Number_Order)),
							values = allocate(maxSize)
						let head = 0,
							count = 0,
							sum = 0,
							min = Number.MAX_VALUE,
							max = Number.MIN_VALUE
						const snapshot = now => {
							const builder = []
							let i = 0
							for (; i !== maxSize - 1; ) {
								const item = values[i]
								if (null != item) {
									const [t, v] = item,
										age = Duration_millis(now - t)
									Duration_greaterThanOrEqualTo(age, zero) &&
										age <= maxAge &&
										builder.push(v)
								}
								i += 1
							}
							return ((error, sortedQuantiles, sortedSamples) => {
								const sampleCount = sortedSamples.length
								if (!isNonEmptyReadonlyArray(sortedQuantiles)) return []
								const head = sortedQuantiles[0],
									tail = sortedQuantiles.slice(1),
									resolvedHead = resolveQuantile(
										error,
										sampleCount,
										Option_none(),
										0,
										head,
										sortedSamples,
									),
									resolved = Array_of(resolvedHead)
								tail.forEach(quantile => {
									resolved.push(
										resolveQuantile(
											error,
											sampleCount,
											resolvedHead.value,
											resolvedHead.consumed,
											quantile,
											resolvedHead.rest,
										),
									)
								})
								return Array_map(resolved, rq => [rq.quantile, rq.value])
							})(error, sortedQuantiles, sort(builder, Number_Order))
						}
						return hook_make({
							get: () => {
								return (
									(options = {
										error,
										quantiles: snapshot(Date.now()),
										count,
										min,
										max,
										sum,
									}),
									new SummaryState(
										options.error,
										options.quantiles,
										options.count,
										options.min,
										options.max,
										options.sum,
									)
								)
								var options
							},
							update: ([value, timestamp]) =>
								((value, timestamp) => {
									if (maxSize > 0) {
										head += 1
										values[head % maxSize] = [timestamp, value]
									}
									count += 1
									sum += value
									value < min && (min = value)
									value > max && (max = value)
								})(value, timestamp),
						})
					})(key)
					Function_pipe(this.map, MutableHashMap_has(key)) ||
						Function_pipe(this.map, MutableHashMap_set(key, summary))
					value = summary
				}
				return value
			}
		}
		const MetricTypeId = Symbol.for("effect/Metric"),
			metricVariance = { _Type: _ => _, _In: _ => _, _Out: _ => _ },
			globalMetricRegistry = globalValue(
				Symbol.for("effect/Metric/globalMetricRegistry"),
				() => new MetricRegistryImpl(),
			),
			metric_make = function (keyType, unsafeUpdate, unsafeValue) {
				const metric = Object.assign(
					effect => core_tap(effect, a => metric_update(metric, a)),
					{
						[MetricTypeId]: metricVariance,
						keyType,
						unsafeUpdate,
						unsafeValue,
						register() {
							this.unsafeValue([])
							return this
						},
						pipe() {
							return Pipeable_pipeArguments(this, arguments)
						},
					},
				)
				return metric
			},
			metric_counter = (name, options) =>
				fromMetricKey(
					((name, options) =>
						new MetricKeyImpl(
							name,
							(options =>
								new CounterKeyType(
									options?.incremental ?? !1,
									options?.bigint ?? !1,
								))(options),
							fromNullable(options?.description),
						))(name, options),
				),
			fromMetricKey = key => {
				let untaggedHook
				const hookCache = new WeakMap(),
					hook = extraTags => {
						if (0 === extraTags.length) {
							if (void 0 !== untaggedHook) return untaggedHook
							untaggedHook = globalMetricRegistry.get(key)
							return untaggedHook
						}
						let hook = hookCache.get(extraTags)
						if (void 0 !== hook) return hook
						hook = globalMetricRegistry.get(taggedWithLabels(key, extraTags))
						hookCache.set(extraTags, hook)
						return hook
					}
				return metric_make(
					key.keyType,
					(input, extraTags) => hook(extraTags).update(input),
					extraTags => hook(extraTags).get(),
				)
			},
			metric_histogram = (name, boundaries, description) =>
				fromMetricKey(
					((name, boundaries, description) =>
						new MetricKeyImpl(
							name,
							(boundaries => new HistogramKeyType(boundaries))(boundaries),
							fromNullable(description),
						))(name, boundaries, description),
				),
			metric_tagged = Function_dual(3, (self, key, value) =>
				metric_taggedWithLabels(self, [label_make(key, value)]),
			),
			metric_taggedWithLabels = Function_dual(2, (self, extraTags) =>
				metric_make(
					self.keyType,
					(input, extraTags1) =>
						self.unsafeUpdate(input, Array_union(extraTags, extraTags1)),
					extraTags1 => self.unsafeValue(Array_union(extraTags, extraTags1)),
				),
			),
			metric_update = Function_dual(2, (self, input) =>
				fiberRefGetWith(currentMetricLabels, tags =>
					sync(() => self.unsafeUpdate(input, tags)),
				),
			),
			MetricBoundariesTypeId = Symbol.for("effect/MetricBoundaries")
		class MetricBoundariesImpl {
			values;
			[MetricBoundariesTypeId] = MetricBoundariesTypeId
			constructor(values) {
				this.values = values
				this._hash = Function_pipe(
					string("effect/MetricBoundaries"),
					combine(array(this.values)),
				)
			}
			_hash;
			[symbol]() {
				return this._hash
			}
			[Equal_symbol](u) {
				return isMetricBoundaries(u) && equals(this.values, u.values)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const isMetricBoundaries = u =>
				Predicate_hasProperty(u, MetricBoundariesTypeId),
			boundaries_fromIterable = iterable => {
				const values = Function_pipe(
					iterable,
					Array_appendAll(Chunk_of(Number.POSITIVE_INFINITY)),
					dedupe,
				)
				return new MetricBoundariesImpl(values)
			},
			exponential = options =>
				Function_pipe(
					Array_makeBy(
						options.count - 1,
						i => options.start * Math.pow(options.factor, i),
					),
					unsafeFromArray,
					boundaries_fromIterable,
				),
			request_complete = Function_dual(2, (self, result) =>
				fiberRefGetWith(currentRequestMap, map =>
					sync(() => {
						if (map.has(self)) {
							const entry = map.get(self)
							if (!entry.state.completed) {
								entry.state.completed = !0
								deferredUnsafeDone(entry.result, result)
							}
						}
					}),
				),
			),
			SupervisorTypeId = Symbol.for("effect/Supervisor"),
			supervisorVariance = { _T: _ => _ }
		class ProxySupervisor {
			underlying
			value0;
			[SupervisorTypeId] = supervisorVariance
			constructor(underlying, value0) {
				this.underlying = underlying
				this.value0 = value0
			}
			get value() {
				return this.value0
			}
			onStart(context, effect, parent, fiber) {
				this.underlying.onStart(context, effect, parent, fiber)
			}
			onEnd(value, fiber) {
				this.underlying.onEnd(value, fiber)
			}
			onEffect(fiber, effect) {
				this.underlying.onEffect(fiber, effect)
			}
			onSuspend(fiber) {
				this.underlying.onSuspend(fiber)
			}
			onResume(fiber) {
				this.underlying.onResume(fiber)
			}
			map(f) {
				return new ProxySupervisor(this, Function_pipe(this.value, core_map(f)))
			}
			zip(right) {
				return new Zip(this, right)
			}
		}
		class Zip {
			left
			right
			_tag = "Zip";
			[SupervisorTypeId] = supervisorVariance
			constructor(left, right) {
				this.left = left
				this.right = right
			}
			get value() {
				return core_zip(this.left.value, this.right.value)
			}
			onStart(context, effect, parent, fiber) {
				this.left.onStart(context, effect, parent, fiber)
				this.right.onStart(context, effect, parent, fiber)
			}
			onEnd(value, fiber) {
				this.left.onEnd(value, fiber)
				this.right.onEnd(value, fiber)
			}
			onEffect(fiber, effect) {
				this.left.onEffect(fiber, effect)
				this.right.onEffect(fiber, effect)
			}
			onSuspend(fiber) {
				this.left.onSuspend(fiber)
				this.right.onSuspend(fiber)
			}
			onResume(fiber) {
				this.left.onResume(fiber)
				this.right.onResume(fiber)
			}
			map(f) {
				return new ProxySupervisor(this, Function_pipe(this.value, core_map(f)))
			}
			zip(right) {
				return new Zip(this, right)
			}
		}
		const isZip = self =>
			Predicate_hasProperty(self, SupervisorTypeId) &&
			Predicate_isTagged(self, "Zip")
		class Const {
			effect;
			[SupervisorTypeId] = supervisorVariance
			constructor(effect) {
				this.effect = effect
			}
			get value() {
				return this.effect
			}
			onStart(_context, _effect, _parent, _fiber) {}
			onEnd(_value, _fiber) {}
			onEffect(_fiber, _effect) {}
			onSuspend(_fiber) {}
			onResume(_fiber) {}
			map(f) {
				return new ProxySupervisor(this, Function_pipe(this.value, core_map(f)))
			}
			zip(right) {
				return new Zip(this, right)
			}
			onRun(execution, _fiber) {
				return execution()
			}
		}
		const supervisor_none = globalValue(
				"effect/Supervisor/none",
				() => new Const(core_void_),
			),
			supervisor_patch_empty = { _tag: "Empty" },
			supervisor_patch_combine = (self, that) => ({
				_tag: "AndThen",
				first: self,
				second: that,
			}),
			removeSupervisor = (self, that) =>
				equals(self, that)
					? supervisor_none
					: isZip(self)
						? removeSupervisor(self.left, that).zip(
								removeSupervisor(self.right, that),
							)
						: self,
			patch_toSet = self =>
				equals(self, supervisor_none)
					? HashSet_empty()
					: isZip(self)
						? Function_pipe(
								patch_toSet(self.left),
								HashSet_union(patch_toSet(self.right)),
							)
						: HashSet_make(self),
			patch_differ = differ_make({
				empty: supervisor_patch_empty,
				patch: (self, supervisor) =>
					((_supervisor, _patches) => {
						let supervisor = _supervisor,
							patches = _patches
						for (; isNonEmpty(patches); ) {
							const head = Chunk_headNonEmpty(patches)
							switch (head._tag) {
								case "Empty":
									patches = Chunk_tailNonEmpty(patches)
									break
								case "AddSupervisor":
									supervisor = supervisor.zip(head.supervisor)
									patches = Chunk_tailNonEmpty(patches)
									break
								case "RemoveSupervisor":
									supervisor = removeSupervisor(supervisor, head.supervisor)
									patches = Chunk_tailNonEmpty(patches)
									break
								case "AndThen":
									patches = Chunk_prepend(head.first)(
										Chunk_prepend(head.second)(Chunk_tailNonEmpty(patches)),
									)
							}
						}
						return supervisor
					})(supervisor, Chunk_of(self)),
				combine: supervisor_patch_combine,
				diff: (oldValue, newValue) => {
					if (equals(oldValue, newValue)) return supervisor_patch_empty
					const oldSupervisors = patch_toSet(oldValue),
						newSupervisors = patch_toSet(newValue),
						added = Function_pipe(
							newSupervisors,
							HashSet_difference(oldSupervisors),
							HashSet_reduce(supervisor_patch_empty, (patch, supervisor) =>
								supervisor_patch_combine(patch, {
									_tag: "AddSupervisor",
									supervisor,
								}),
							),
						),
						removed = Function_pipe(
							oldSupervisors,
							HashSet_difference(newSupervisors),
							HashSet_reduce(supervisor_patch_empty, (patch, supervisor) =>
								supervisor_patch_combine(patch, {
									_tag: "RemoveSupervisor",
									supervisor,
								}),
							),
						)
					return supervisor_patch_combine(added, removed)
				},
			}),
			fiberStarted = metric_counter("effect_fiber_started", {
				incremental: !0,
			}),
			fiberActive = metric_counter("effect_fiber_active"),
			fiberSuccesses = metric_counter("effect_fiber_successes", {
				incremental: !0,
			}),
			fiberFailures = metric_counter("effect_fiber_failures", {
				incremental: !0,
			}),
			fiberLifetimes = metric_tagged(
				metric_histogram(
					"effect_fiber_lifetimes",
					exponential({ start: 0.5, factor: 2, count: 35 }),
				),
				"time_unit",
				"milliseconds",
			),
			runtimeFiberVariance = { _E: _ => _, _A: _ => _ },
			fiberRuntime_absurd = _ => {
				throw new Error(
					`BUG: FiberRuntime - ${toStringUnknown(_)} - please report an issue at https://github.com/Effect-TS/effect/issues`,
				)
			},
			YieldedOp = Symbol.for("effect/internal/fiberRuntime/YieldedOp"),
			yieldedOpChannel = globalValue(
				"effect/internal/fiberRuntime/yieldedOpChannel",
				() => ({ currentOp: null }),
			),
			contOpSuccess = {
				OnSuccess: (_, cont, value) =>
					internalCall(() => cont.effect_instruction_i1(value)),
				OnStep: (_, _cont, value) => exitSucceed(exitSucceed(value)),
				OnSuccessAndFailure: (_, cont, value) =>
					internalCall(() => cont.effect_instruction_i2(value)),
				RevertFlags: (self, cont, value) => {
					self.patchRuntimeFlags(self._runtimeFlags, cont.patch)
					return interruptible(self._runtimeFlags) && self.isInterrupted()
						? exitFailCause(self.getInterruptedCause())
						: exitSucceed(value)
				},
				While: (self, cont, value) => {
					internalCall(() => cont.effect_instruction_i2(value))
					if (internalCall(() => cont.effect_instruction_i0())) {
						self.pushStack(cont)
						return internalCall(() => cont.effect_instruction_i1())
					}
					return core_void_
				},
			},
			drainQueueWhileRunningTable = {
				InterruptSignal: (self, runtimeFlags, cur, message) => {
					self.processNewInterruptSignal(message.cause)
					return interruptible(runtimeFlags)
						? exitFailCause(message.cause)
						: cur
				},
				Resume: (_self, _runtimeFlags, _cur, _message) => {
					throw new Error(
						"It is illegal to have multiple concurrent run loops in a single fiber",
					)
				},
				Stateful: (self, runtimeFlags, cur, message) => {
					message.onFiber(self, FiberStatus_running(runtimeFlags))
					return cur
				},
				YieldNow: (_self, _runtimeFlags, cur, _message) =>
					core_flatMap(yieldNow(), () => cur),
			}
		class FiberRuntime {
			[FiberTypeId] = fiberVariance;
			[RuntimeFiberTypeId] = runtimeFiberVariance
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
			_fiberRefs
			_fiberId
			_runtimeFlags
			_queue = new Array()
			_children = null
			_observers = new Array()
			_running = !1
			_stack = []
			_asyncInterruptor = null
			_asyncBlockingOn = null
			_exitValue = null
			_steps = []
			_supervisor
			_scheduler
			_tracer
			currentOpCount = 0
			isYielding = !1
			constructor(fiberId, fiberRefs0, runtimeFlags0) {
				this._runtimeFlags = runtimeFlags0
				this._fiberId = fiberId
				this._fiberRefs = fiberRefs0
				this._supervisor = this.getFiberRef(currentSupervisor)
				this._scheduler = this.getFiberRef(currentScheduler)
				if (runtimeMetrics(runtimeFlags0)) {
					const tags = this.getFiberRef(currentMetricLabels)
					fiberStarted.unsafeUpdate(1, tags)
					fiberActive.unsafeUpdate(1, tags)
				}
				this._tracer = Context_get(this.getFiberRef(currentServices), tracerTag)
			}
			id() {
				return this._fiberId
			}
			resume(effect) {
				this.tell(resume(effect))
			}
			get status() {
				return this.ask((_, status) => status)
			}
			get runtimeFlags() {
				return this.ask((state, status) =>
					(self => "Done" === self._tag)(status)
						? state._runtimeFlags
						: status.runtimeFlags,
				)
			}
			scope() {
				return new Local((fiber = this).id(), fiber)
				var fiber
			}
			get children() {
				return this.ask(fiber => Array.from(fiber.getChildren()))
			}
			getChildren() {
				null === this._children && (this._children = new Set())
				return this._children
			}
			getInterruptedCause() {
				return this.getFiberRef(currentInterruptedCause)
			}
			fiberRefs() {
				return this.ask(fiber => fiber.getFiberRefs())
			}
			ask(f) {
				return suspend(() => {
					const deferred = deferredUnsafeMake(this._fiberId)
					this.tell(
						stateful((fiber, status) => {
							deferredUnsafeDone(
								deferred,
								sync(() => f(fiber, status)),
							)
						}),
					)
					return deferredAwait(deferred)
				})
			}
			tell(message) {
				this._queue.push(message)
				if (!this._running) {
					this._running = !0
					this.drainQueueLaterOnExecutor()
				}
			}
			get await() {
				return core_async(resume => {
					const cb = exit => resume(succeed(exit))
					this.tell(
						stateful((fiber, _) => {
							null !== fiber._exitValue
								? cb(this._exitValue)
								: fiber.addObserver(cb)
						}),
					)
					return sync(() =>
						this.tell(
							stateful((fiber, _) => {
								fiber.removeObserver(cb)
							}),
						),
					)
				}, this.id())
			}
			get inheritAll() {
				return withFiberRuntime((parentFiber, parentStatus) => {
					const parentFiberId = parentFiber.id(),
						parentFiberRefs = parentFiber.getFiberRefs(),
						parentRuntimeFlags = parentStatus.runtimeFlags,
						childFiberRefs = this.getFiberRefs(),
						updatedFiberRefs = joinAs(
							parentFiberRefs,
							parentFiberId,
							childFiberRefs,
						)
					parentFiber.setFiberRefs(updatedFiberRefs)
					const updatedRuntimeFlags =
						parentFiber.getFiberRef(currentRuntimeFlags)
					return (patch => {
						const effect = new EffectPrimitive("UpdateRuntimeFlags")
						effect.effect_instruction_i0 = patch
						effect.effect_instruction_i1 = void 0
						return effect
					})(
						Function_pipe(
							runtimeFlags_diff(parentRuntimeFlags, updatedRuntimeFlags),
							RuntimeFlagsPatch_exclude(1),
							RuntimeFlagsPatch_exclude(16),
						),
					)
				})
			}
			get poll() {
				return sync(() => fromNullable(this._exitValue))
			}
			unsafePoll() {
				return this._exitValue
			}
			interruptAsFork(fiberId) {
				return sync(() => this.tell(interruptSignal(interrupt(fiberId))))
			}
			unsafeInterruptAsFork(fiberId) {
				this.tell(interruptSignal(interrupt(fiberId)))
			}
			addObserver(observer) {
				null !== this._exitValue
					? observer(this._exitValue)
					: this._observers.push(observer)
			}
			removeObserver(observer) {
				this._observers = this._observers.filter(o => o !== observer)
			}
			getFiberRefs() {
				this.setFiberRef(currentRuntimeFlags, this._runtimeFlags)
				return this._fiberRefs
			}
			unsafeDeleteFiberRef(fiberRef) {
				this._fiberRefs = delete_(this._fiberRefs, fiberRef)
			}
			getFiberRef(fiberRef) {
				return this._fiberRefs.locals.has(fiberRef)
					? this._fiberRefs.locals.get(fiberRef)[0][1]
					: fiberRef.initial
			}
			setFiberRef(fiberRef, value) {
				this._fiberRefs = updateAs(this._fiberRefs, {
					fiberId: this._fiberId,
					fiberRef,
					value,
				})
				this.refreshRefCache()
			}
			refreshRefCache() {
				this._tracer = Context_get(this.getFiberRef(currentServices), tracerTag)
				this._supervisor = this.getFiberRef(currentSupervisor)
				this._scheduler = this.getFiberRef(currentScheduler)
			}
			setFiberRefs(fiberRefs) {
				this._fiberRefs = fiberRefs
				this.refreshRefCache()
			}
			addChild(child) {
				this.getChildren().add(child)
			}
			removeChild(child) {
				this.getChildren().delete(child)
			}
			drainQueueOnCurrentThread() {
				let recurse = !0
				for (; recurse; ) {
					let evaluationSignal = "Continue"
					const prev = globalThis[currentFiberURI]
					globalThis[currentFiberURI] = this
					try {
						for (; "Continue" === evaluationSignal; )
							evaluationSignal =
								0 === this._queue.length
									? "Done"
									: this.evaluateMessageWhileSuspended(
											this._queue.splice(0, 1)[0],
										)
					} finally {
						this._running = !1
						globalThis[currentFiberURI] = prev
					}
					if (this._queue.length > 0 && !this._running) {
						this._running = !0
						if ("Yield" === evaluationSignal) {
							this.drainQueueLaterOnExecutor()
							recurse = !1
						} else recurse = !0
					} else recurse = !1
				}
			}
			drainQueueLaterOnExecutor() {
				this._scheduler.scheduleTask(
					this.run,
					this.getFiberRef(currentSchedulingPriority),
				)
			}
			drainQueueWhileRunning(runtimeFlags, cur0) {
				let cur = cur0
				for (; this._queue.length > 0; ) {
					const message = this._queue.splice(0, 1)[0]
					cur = drainQueueWhileRunningTable[message._tag](
						this,
						runtimeFlags,
						cur,
						message,
					)
				}
				return cur
			}
			isInterrupted() {
				return !(self =>
					"Empty" === self._tag ||
					cause_reduce(self, !0, (acc, cause) => {
						switch (cause._tag) {
							case "Empty":
								return Option_some(acc)
							case "Die":
							case "Fail":
							case "Interrupt":
								return Option_some(!1)
							default:
								return Option_none()
						}
					}))(this.getFiberRef(currentInterruptedCause))
			}
			addInterruptedCause(cause) {
				const oldSC = this.getFiberRef(currentInterruptedCause)
				this.setFiberRef(currentInterruptedCause, sequential(oldSC, cause))
			}
			processNewInterruptSignal(cause) {
				this.addInterruptedCause(cause)
				this.sendInterruptSignalToAllChildren()
			}
			sendInterruptSignalToAllChildren() {
				if (null === this._children || 0 === this._children.size) return !1
				let told = !1
				for (const child of this._children) {
					child.tell(interruptSignal(interrupt(this.id())))
					told = !0
				}
				return told
			}
			interruptAllChildren() {
				if (this.sendInterruptSignalToAllChildren()) {
					const it = this._children.values()
					this._children = null
					let isDone = !1
					return whileLoop({
						while: () => !isDone,
						body: () => {
							const next = it.next()
							return next.done
								? sync(() => {
										isDone = !0
									})
								: core_asVoid(next.value.await)
						},
						step: () => {},
					})
				}
				return null
			}
			reportExitValue(exit) {
				if (runtimeMetrics(this._runtimeFlags)) {
					const tags = this.getFiberRef(currentMetricLabels),
						startTimeMillis = this.id().startTimeMillis,
						endTimeMillis = Date.now()
					fiberLifetimes.unsafeUpdate(endTimeMillis - startTimeMillis, tags)
					fiberActive.unsafeUpdate(-1, tags)
					switch (exit._tag) {
						case "Success":
							fiberSuccesses.unsafeUpdate(1, tags)
							break
						case "Failure":
							fiberFailures.unsafeUpdate(1, tags)
					}
				}
				if ("Failure" === exit._tag) {
					const level = this.getFiberRef(currentUnhandledErrorLogLevel)
					isInterruptedOnly(exit.cause) ||
						"Some" !== level._tag ||
						this.log(
							"Fiber terminated with an unhandled error",
							exit.cause,
							level,
						)
				}
			}
			setExitValue(exit) {
				this._exitValue = exit
				this.reportExitValue(exit)
				for (let i = this._observers.length - 1; i >= 0; i--)
					this._observers[i](exit)
			}
			getLoggers() {
				return this.getFiberRef(currentLoggers)
			}
			log(message, cause, overrideLogLevel) {
				const logLevel = Option_isSome(overrideLogLevel)
						? overrideLogLevel.value
						: this.getFiberRef(currentLogLevel),
					minimumLogLevel = this.getFiberRef(currentMinimumLogLevel)
				if (LogLevel_greaterThan(minimumLogLevel, logLevel)) return
				const spans = this.getFiberRef(currentLogSpan),
					annotations = this.getFiberRef(currentLogAnnotations),
					loggers = this.getLoggers(),
					contextMap = this.getFiberRefs()
				if (HashSet_size(loggers) > 0) {
					const clockService = Context_get(
							this.getFiberRef(currentServices),
							clockTag,
						),
						date = new Date(clockService.unsafeCurrentTimeMillis())
					for (const logger of loggers)
						logger.log({
							fiberId: this.id(),
							logLevel,
							message,
							cause,
							context: contextMap,
							spans,
							annotations,
							date,
						})
				}
			}
			evaluateMessageWhileSuspended(message) {
				switch (message._tag) {
					case "YieldNow":
						return "Yield"
					case "InterruptSignal":
						this.processNewInterruptSignal(message.cause)
						if (null !== this._asyncInterruptor) {
							this._asyncInterruptor(exitFailCause(message.cause))
							this._asyncInterruptor = null
						}
						return "Continue"
					case "Resume":
						this._asyncInterruptor = null
						this._asyncBlockingOn = null
						this.evaluateEffect(message.effect)
						return "Continue"
					case "Stateful":
						message.onFiber(
							this,
							null !== this._exitValue
								? FiberStatus_done
								: ((runtimeFlags = this._runtimeFlags),
									(blockingOn = this._asyncBlockingOn),
									new Suspended(runtimeFlags, blockingOn)),
						)
						return "Continue"
					default:
						return fiberRuntime_absurd(message)
				}
				var runtimeFlags, blockingOn
			}
			evaluateEffect(effect0) {
				this._supervisor.onResume(this)
				try {
					let effect =
						interruptible(this._runtimeFlags) && this.isInterrupted()
							? exitFailCause(this.getInterruptedCause())
							: effect0
					for (; null !== effect; ) {
						const eff = effect,
							exit = this.runLoop(eff)
						if (exit === YieldedOp) {
							const op = yieldedOpChannel.currentOp
							yieldedOpChannel.currentOp = null
							if ("Yield" === op._op)
								if (cooperativeYielding(this._runtimeFlags)) {
									this.tell({ _tag: "YieldNow" })
									this.tell(resume(exitVoid))
									effect = null
								} else effect = exitVoid
							else "Async" === op._op && (effect = null)
						} else {
							this._runtimeFlags = Function_pipe(
								this._runtimeFlags,
								runtimeFlags_enable(16),
							)
							const interruption = this.interruptAllChildren()
							if (null !== interruption)
								effect = core_flatMap(interruption, () => exit)
							else {
								0 === this._queue.length
									? this.setExitValue(exit)
									: this.tell(resume(exit))
								effect = null
							}
						}
					}
				} finally {
					this._supervisor.onSuspend(this)
				}
			}
			start(effect) {
				if (this._running) this.tell(resume(effect))
				else {
					this._running = !0
					const prev = globalThis[currentFiberURI]
					globalThis[currentFiberURI] = this
					try {
						this.evaluateEffect(effect)
					} finally {
						this._running = !1
						globalThis[currentFiberURI] = prev
						this._queue.length > 0 && this.drainQueueLaterOnExecutor()
					}
				}
			}
			startFork(effect) {
				this.tell(resume(effect))
			}
			patchRuntimeFlags(oldRuntimeFlags, patch) {
				const newRuntimeFlags = runtimeFlags_patch(oldRuntimeFlags, patch)
				globalThis[currentFiberURI] = this
				this._runtimeFlags = newRuntimeFlags
				return newRuntimeFlags
			}
			initiateAsync(runtimeFlags, asyncRegister) {
				let alreadyCalled = !1
				const callback = effect => {
					if (!alreadyCalled) {
						alreadyCalled = !0
						this.tell(resume(effect))
					}
				}
				interruptible(runtimeFlags) && (this._asyncInterruptor = callback)
				try {
					asyncRegister(callback)
				} catch (e) {
					callback(failCause(die(e)))
				}
			}
			pushStack(cont) {
				this._stack.push(cont)
				"OnStep" === cont._op &&
					this._steps.push({
						refs: this.getFiberRefs(),
						flags: this._runtimeFlags,
					})
			}
			popStack() {
				const item = this._stack.pop()
				if (item) {
					"OnStep" === item._op && this._steps.pop()
					return item
				}
			}
			getNextSuccessCont() {
				let frame = this.popStack()
				for (; frame; ) {
					if ("OnFailure" !== frame._op) return frame
					frame = this.popStack()
				}
			}
			getNextFailCont() {
				let frame = this.popStack()
				for (; frame; ) {
					if ("OnSuccess" !== frame._op && "While" !== frame._op) return frame
					frame = this.popStack()
				}
			}
			Tag(op) {
				return core_map(fiberRefGet(currentContext), context =>
					Context_unsafeGet(context, op),
				)
			}
			Left(op) {
				return core_fail(op.left)
			}
			None(_) {
				return core_fail(new NoSuchElementException())
			}
			Right(op) {
				return exitSucceed(op.right)
			}
			Some(op) {
				return exitSucceed(op.value)
			}
			Micro(op) {
				return ((register, blockingOn = FiberId_none) => {
					const effect = new EffectPrimitive("Async")
					let cancelerRef
					effect.effect_instruction_i0 = resume => {
						cancelerRef = register(resume)
					}
					effect.effect_instruction_i1 = blockingOn
					return void 0 !== cancelerRef
						? onInterrupt(effect, _ => cancelerRef)
						: effect
				})(microResume => {
					const env = (() => {
						const controller = new AbortController(),
							refs = Object.create(null)
						refs[currentAbortController.key] = controller
						refs[currentAbortSignal.key] = controller.signal
						return envMake(refs)
					})().pipe(
						envSet(Micro_currentContext, this.getFiberRef(currentContext)),
					)
					let resume = microResume
					op[runSymbol](env, result => {
						if ("Right" === result._tag)
							return resume(exitSucceed(result.right))
						switch (result.left._tag) {
							case "Interrupt":
								return resume(exitFailCause(interrupt(FiberId_none)))
							case "Fail":
								return resume(core_fail(result.left.error))
							case "Die":
								return resume(core_die(result.left.defect))
						}
					})
					return core_async(abortResume => {
						resume = _ => {
							abortResume(core_void_)
						}
						envGet(env, currentAbortController).abort()
					})
				})
			}
			Sync(op) {
				const value = internalCall(() => op.effect_instruction_i0()),
					cont = this.getNextSuccessCont()
				if (void 0 !== cont) {
					cont._op in contOpSuccess || fiberRuntime_absurd(cont)
					return contOpSuccess[cont._op](this, cont, value)
				}
				yieldedOpChannel.currentOp = exitSucceed(value)
				return YieldedOp
			}
			Success(op) {
				const oldCur = op,
					cont = this.getNextSuccessCont()
				if (void 0 !== cont) {
					cont._op in contOpSuccess || fiberRuntime_absurd(cont)
					return contOpSuccess[cont._op](
						this,
						cont,
						oldCur.effect_instruction_i0,
					)
				}
				yieldedOpChannel.currentOp = oldCur
				return YieldedOp
			}
			Failure(op) {
				const cause = op.effect_instruction_i0,
					cont = this.getNextFailCont()
				if (void 0 === cont) {
					yieldedOpChannel.currentOp = exitFailCause(cause)
					return YieldedOp
				}
				switch (cont._op) {
					case "OnFailure":
					case "OnSuccessAndFailure":
						return interruptible(this._runtimeFlags) && this.isInterrupted()
							? exitFailCause(stripFailures(cause))
							: internalCall(() => cont.effect_instruction_i1(cause))
					case "OnStep":
						return interruptible(this._runtimeFlags) && this.isInterrupted()
							? exitFailCause(stripFailures(cause))
							: exitSucceed(exitFailCause(cause))
					case "RevertFlags":
						this.patchRuntimeFlags(this._runtimeFlags, cont.patch)
						return interruptible(this._runtimeFlags) && this.isInterrupted()
							? exitFailCause(sequential(cause, this.getInterruptedCause()))
							: exitFailCause(cause)
					default:
						fiberRuntime_absurd(cont)
				}
			}
			WithRuntime(op) {
				return internalCall(() =>
					op.effect_instruction_i0(
						this,
						FiberStatus_running(this._runtimeFlags),
					),
				)
			}
			Blocked(op) {
				const refs = this.getFiberRefs(),
					flags = this._runtimeFlags
				if (this._steps.length > 0) {
					const frames = [],
						snap = this._steps[this._steps.length - 1]
					let frame = this.popStack()
					for (; frame && "OnStep" !== frame._op; ) {
						frames.push(frame)
						frame = this.popStack()
					}
					this.setFiberRefs(snap.refs)
					this._runtimeFlags = snap.flags
					const patchRefs = FiberRefsPatch_diff(snap.refs, refs),
						patchFlags = runtimeFlags_diff(snap.flags, flags)
					return exitSucceed(
						blocked(
							op.effect_instruction_i0,
							withFiberRuntime(newFiber => {
								for (; frames.length > 0; ) newFiber.pushStack(frames.pop())
								newFiber.setFiberRefs(
									FiberRefsPatch_patch(
										newFiber.id(),
										newFiber.getFiberRefs(),
									)(patchRefs),
								)
								newFiber._runtimeFlags = runtimeFlags_patch(patchFlags)(
									newFiber._runtimeFlags,
								)
								return op.effect_instruction_i1
							}),
						),
					)
				}
				return uninterruptibleMask(restore =>
					core_flatMap(
						fiberRuntime_forkDaemon(
							(blockedRequests => {
								const effect = new EffectPrimitive("RunBlocked")
								effect.effect_instruction_i0 = blockedRequests
								return effect
							})(op.effect_instruction_i0),
						),
						() => restore(op.effect_instruction_i1),
					),
				)
			}
			RunBlocked(op) {
				return (self =>
					forEachSequentialDiscard(
						(self => {
							let current = List_of(self),
								updated = List_empty()
							for (;;) {
								const [parallel, sequential] = List_reduce(
									current,
									[parallelCollectionEmpty(), List_empty()],
									([parallel, sequential], blockedRequest) => {
										const [par, seq] = blockedRequests_step(blockedRequest)
										return [
											parallelCollectionCombine(parallel, par),
											List_appendAll(sequential, seq),
										]
									},
								)
								updated = blockedRequests_merge(updated, parallel)
								if (isNil(sequential)) return List_reverse(updated)
								current = sequential
							}
							throw new Error(
								"BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/effect/issues",
							)
						})(self),
						requestsByRequestResolver =>
							forEachConcurrentDiscard(
								(self => Array.from(self.map))(requestsByRequestResolver),
								([dataSource, sequential]) => {
									const map = new Map(),
										arr = []
									for (const block of sequential) {
										arr.push(toReadonlyArray(block))
										for (const entry of block) map.set(entry.request, entry)
									}
									const flat = arr.flat()
									return fiberRefLocally(
										invokeWithInterrupt(dataSource.runAll(arr), flat, () =>
											flat.forEach(entry => {
												entry.listeners.interrupted = !0
											}),
										),
										currentRequestMap,
										map,
									)
								},
								!1,
								!1,
							),
					))(op.effect_instruction_i0)
			}
			UpdateRuntimeFlags(op) {
				const updateFlags = op.effect_instruction_i0,
					oldRuntimeFlags = this._runtimeFlags,
					newRuntimeFlags = runtimeFlags_patch(oldRuntimeFlags, updateFlags)
				if (interruptible(newRuntimeFlags) && this.isInterrupted())
					return exitFailCause(this.getInterruptedCause())
				this.patchRuntimeFlags(this._runtimeFlags, updateFlags)
				if (op.effect_instruction_i1) {
					const revertFlags = runtimeFlags_diff(
						newRuntimeFlags,
						oldRuntimeFlags,
					)
					this.pushStack(new RevertFlags(revertFlags, op))
					return internalCall(() => op.effect_instruction_i1(oldRuntimeFlags))
				}
				return exitVoid
			}
			OnSuccess(op) {
				this.pushStack(op)
				return op.effect_instruction_i0
			}
			OnStep(op) {
				this.pushStack(op)
				return op.effect_instruction_i0
			}
			OnFailure(op) {
				this.pushStack(op)
				return op.effect_instruction_i0
			}
			OnSuccessAndFailure(op) {
				this.pushStack(op)
				return op.effect_instruction_i0
			}
			Async(op) {
				this._asyncBlockingOn = op.effect_instruction_i1
				this.initiateAsync(this._runtimeFlags, op.effect_instruction_i0)
				yieldedOpChannel.currentOp = op
				return YieldedOp
			}
			Yield(op) {
				this.isYielding = !1
				yieldedOpChannel.currentOp = op
				return YieldedOp
			}
			While(op) {
				const check = op.effect_instruction_i0,
					body = op.effect_instruction_i1
				if (check()) {
					this.pushStack(op)
					return body()
				}
				return exitVoid
			}
			Commit(op) {
				return internalCall(() => op.commit())
			}
			runLoop(effect0) {
				let cur = effect0
				this.currentOpCount = 0
				for (;;) {
					0 != (2 & this._runtimeFlags) && this._supervisor.onEffect(this, cur)
					this._queue.length > 0 &&
						(cur = this.drainQueueWhileRunning(this._runtimeFlags, cur))
					if (!this.isYielding) {
						this.currentOpCount += 1
						const shouldYield = this._scheduler.shouldYield(this)
						if (!1 !== shouldYield) {
							this.isYielding = !0
							this.currentOpCount = 0
							const oldCur = cur
							cur = core_flatMap(
								yieldNow({ priority: shouldYield }),
								() => oldCur,
							)
						}
					}
					try {
						;("_op" in cur && cur._op in this) || fiberRuntime_absurd(cur)
						cur = this._tracer.context(() => {
							return "3.5.7" !== cur[Effectable_EffectTypeId]._V
								? ((message = `Cannot execute an Effect versioned ${cur[Effectable_EffectTypeId]._V} with a Runtime of version 3.5.7`),
									core_flatMap(
										sync(() => die(new RuntimeException(message))),
										failCause,
									))
								: this[cur._op](cur)
							var message
						}, this)
						if (cur === YieldedOp) {
							const op = yieldedOpChannel.currentOp
							if ("Yield" === op._op || "Async" === op._op) return YieldedOp
							yieldedOpChannel.currentOp = null
							return "Success" === op._op || "Failure" === op._op
								? op
								: exitFailCause(die(op))
						}
					} catch (e) {
						cur = isEffectError(e)
							? exitFailCause(e.cause)
							: isInterruptedException(e)
								? exitFailCause(sequential(die(e), interrupt(FiberId_none)))
								: core_die(e)
					}
				}
			}
			run = () => {
				this.drainQueueOnCurrentThread()
			}
		}
		const currentMinimumLogLevel = globalValue(
				"effect/FiberRef/currentMinimumLogLevel",
				() => fiberRefUnsafeMake(Info),
			),
			defaultLogger = globalValue(
				Symbol.for("effect/Logger/defaultLogger"),
				() =>
					(self =>
						makeLogger(opts => {
							const services = FiberRefs_getOrDefault(
								opts.context,
								currentServices,
							)
							Context_get(services, consoleTag).unsafe.log(self.log(opts))
						}))(stringLogger),
			),
			tracerLogger = globalValue(Symbol.for("effect/Logger/tracerLogger"), () =>
				makeLogger(
					({ annotations, cause, context, fiberId, logLevel, message }) => {
						const span = flatMap(
								fiberRefs_get(context, currentContext),
								Context_getOption(spanTag),
							),
							clockService = map(fiberRefs_get(context, currentServices), _ =>
								Context_get(_, clockTag),
							)
						if (
							"None" === span._tag ||
							"ExternalSpan" === span.value._tag ||
							"None" === clockService._tag
						)
							return
						const attributes = Object.fromEntries(
							HashMap_map(annotations, toStringUnknown),
						)
						attributes["effect.fiberId"] = FiberId_threadName(fiberId)
						attributes["effect.logLevel"] = logLevel.label
						null !== cause &&
							"Empty" !== cause._tag &&
							(attributes["effect.cause"] = pretty(cause))
						span.value.event(
							String(message),
							clockService.value.unsafeCurrentTimeNanos(),
							attributes,
						)
					},
				),
			),
			currentLoggers = globalValue(
				Symbol.for("effect/FiberRef/currentLoggers"),
				() =>
					(initial => {
						const differ = differ_make({
							empty: differ_hashSetPatch_empty(),
							combine: (first, second) => hashSetPatch_combine(second)(first),
							diff: (oldValue, newValue) =>
								((oldValue, newValue) => {
									const [removed, patch] = HashSet_reduce(
										[oldValue, differ_hashSetPatch_empty()],
										([set, patch], value) =>
											HashSet_has(value)(set)
												? [HashSet_remove(value)(set), patch]
												: [
														set,
														hashSetPatch_combine(hashSetPatch_makeAdd(value))(
															patch,
														),
													],
									)(newValue)
									return HashSet_reduce(patch, (patch, value) =>
										hashSetPatch_combine(
											(value => {
												const o = Object.create(hashSetPatch_RemoveProto)
												o.value = value
												return o
											})(value),
										)(patch),
									)(removed)
								})(oldValue, newValue),
							patch: (patch, oldValue) => hashSetPatch_patch(oldValue)(patch),
						})
						return fiberRefUnsafeMakePatch(initial, {
							differ,
							fork: differ.empty,
						})
					})(HashSet_make(defaultLogger, tracerLogger)),
			),
			fiberRuntime_acquireRelease = Function_dual(
				args => isEffect(args[0]),
				(acquire, release) =>
					uninterruptible(
						core_tap(acquire, a =>
							fiberRuntime_addFinalizer(exit => release(a, exit)),
						),
					),
			),
			fiberRuntime_addFinalizer = finalizer =>
				withFiberRuntime(runtime => {
					const acquireRefs = runtime.getFiberRefs(),
						acquireFlags = runtime._runtimeFlags
					return core_flatMap(fiberRuntime_scope, scope =>
						scopeAddFinalizerExit(scope, exit =>
							withFiberRuntime(runtimeFinalizer => {
								const preRefs = runtimeFinalizer.getFiberRefs(),
									preFlags = runtimeFinalizer._runtimeFlags,
									patchRefs = FiberRefsPatch_diff(preRefs, acquireRefs),
									patchFlags = runtimeFlags_diff(preFlags, acquireFlags),
									inverseRefs = FiberRefsPatch_diff(acquireRefs, preRefs)
								runtimeFinalizer.setFiberRefs(
									FiberRefsPatch_patch(
										patchRefs,
										runtimeFinalizer.id(),
										acquireRefs,
									),
								)
								return fiberRuntime_ensuring(
									withRuntimeFlags(finalizer(exit), patchFlags),
									sync(() => {
										runtimeFinalizer.setFiberRefs(
											FiberRefsPatch_patch(
												inverseRefs,
												runtimeFinalizer.id(),
												runtimeFinalizer.getFiberRefs(),
											),
										)
									}),
								)
							}),
						),
					)
				}),
			fiberRuntime_all = (arg, options) => {
				const [effects, reconcile] = (input => {
					if (Array.isArray(input) || Predicate_isIterable(input))
						return [input, Option_none()]
					const keys = Object.keys(input),
						size = keys.length
					return [
						keys.map(k => input[k]),
						Option_some(values => {
							const res = {}
							for (let i = 0; i < size; i++) res[keys[i]] = values[i]
							return res
						}),
					]
				})(arg)
				return "validate" === options?.mode
					? ((effects, reconcile, options) => {
							const eitherEffects = []
							for (const effect of effects)
								eitherEffects.push(core_either(effect))
							return core_flatMap(
								fiberRuntime_forEach(eitherEffects, Function_identity, {
									concurrency: options?.concurrency,
									batching: options?.batching,
								}),
								eithers => {
									const none = Option_none(),
										size = eithers.length,
										errors = new Array(size),
										successes = new Array(size)
									let errored = !1
									for (let i = 0; i < size; i++) {
										const either = eithers[i]
										if ("Left" === either._tag) {
											errors[i] = Option_some(either.left)
											errored = !0
										} else {
											successes[i] = either.right
											errors[i] = none
										}
									}
									return errored
										? "Some" === reconcile._tag
											? core_fail(reconcile.value(errors))
											: core_fail(errors)
										: options?.discard
											? core_void_
											: "Some" === reconcile._tag
												? succeed(reconcile.value(successes))
												: succeed(successes)
								},
							)
						})(effects, reconcile, options)
					: "either" === options?.mode
						? ((effects, reconcile, options) => {
								const eitherEffects = []
								for (const effect of effects)
									eitherEffects.push(core_either(effect))
								return options?.discard
									? fiberRuntime_forEach(eitherEffects, Function_identity, {
											concurrency: options?.concurrency,
											batching: options?.batching,
											discard: !0,
										})
									: core_map(
											fiberRuntime_forEach(eitherEffects, Function_identity, {
												concurrency: options?.concurrency,
												batching: options?.batching,
											}),
											eithers =>
												"Some" === reconcile._tag
													? reconcile.value(eithers)
													: eithers,
										)
							})(effects, reconcile, options)
						: !0 !== options?.discard && "Some" === reconcile._tag
							? core_map(
									fiberRuntime_forEach(effects, Function_identity, options),
									reconcile.value,
								)
							: fiberRuntime_forEach(effects, Function_identity, options)
			},
			fiberRuntime_forEach = Function_dual(
				args => Predicate_isIterable(args[0]),
				(self, f, options) =>
					withFiberRuntime(r => {
						const isRequestBatchingEnabled =
							!0 === options?.batching ||
							("inherit" === options?.batching &&
								r.getFiberRef(currentRequestBatching))
						return options?.discard
							? concurrency_match(
									options.concurrency,
									() =>
										finalizersMask(ExecutionStrategy_sequential)(restore =>
											isRequestBatchingEnabled
												? forEachConcurrentDiscard(
														self,
														(a, i) => restore(f(a, i)),
														!0,
														!1,
														1,
													)
												: forEachSequentialDiscard(self, (a, i) =>
														restore(f(a, i)),
													),
										),
									() =>
										finalizersMask(ExecutionStrategy_parallel)(restore =>
											forEachConcurrentDiscard(
												self,
												(a, i) => restore(f(a, i)),
												isRequestBatchingEnabled,
												!1,
											),
										),
									n =>
										finalizersMask(ExecutionStrategy_parallelN(n))(restore =>
											forEachConcurrentDiscard(
												self,
												(a, i) => restore(f(a, i)),
												isRequestBatchingEnabled,
												!1,
												n,
											),
										),
								)
							: concurrency_match(
									options?.concurrency,
									() =>
										finalizersMask(ExecutionStrategy_sequential)(restore =>
											isRequestBatchingEnabled
												? forEachParN(self, 1, (a, i) => restore(f(a, i)), !0)
												: forEachSequential(self, (a, i) => restore(f(a, i))),
										),
									() =>
										finalizersMask(ExecutionStrategy_parallel)(restore =>
											forEachParUnbounded(
												self,
												(a, i) => restore(f(a, i)),
												isRequestBatchingEnabled,
											),
										),
									n =>
										finalizersMask(ExecutionStrategy_parallelN(n))(restore =>
											forEachParN(
												self,
												n,
												(a, i) => restore(f(a, i)),
												isRequestBatchingEnabled,
											),
										),
								)
					}),
			),
			forEachParUnbounded = (self, f, batching) =>
				suspend(() => {
					const as = Array_fromIterable(self),
						array = new Array(as.length)
					return core_zipRight(
						forEachConcurrentDiscard(
							as,
							(a, i) => core_flatMap(f(a, i), b => sync(() => (array[i] = b))),
							batching,
							!1,
						),
						succeed(array),
					)
				}),
			forEachConcurrentDiscard = (self, f, batching, processAll, n) =>
				uninterruptibleMask(restore =>
					(f =>
						withFiberRuntime(state => {
							const scope = Function_pipe(
								state.getFiberRef(currentForkScopeOverride),
								getOrElse(() => state.scope()),
							)
							return f(
								fiberRefLocally(currentForkScopeOverride, Option_some(scope)),
							)
						}))(graft =>
						withFiberRuntime(parent => {
							let todos = Array.from(self).reverse(),
								target = todos.length
							if (0 === target) return core_void_
							let counter = 0,
								interrupted = !1
							const fibersCount = n ? Math.min(todos.length, n) : todos.length,
								fibers = new Set(),
								results = new Array(),
								startOrder = new Array(),
								joinOrder = new Array(),
								residual = new Array(),
								collectExits = () => {
									const exits = results
										.filter(({ exit }) => "Failure" === exit._tag)
										.sort((a, b) =>
											a.index < b.index ? -1 : a.index === b.index ? 0 : 1,
										)
										.map(({ exit }) => exit)
									0 === exits.length && exits.push(exitVoid)
									return exits
								},
								runFiber = (eff, interruptImmediately = !1) => {
									const runnable = uninterruptible(graft(eff)),
										fiber = unsafeForkUnstarted(
											runnable,
											parent,
											parent._runtimeFlags,
											globalScope,
										)
									parent._scheduler.scheduleTask(() => {
										interruptImmediately &&
											fiber.unsafeInterruptAsFork(parent.id())
										fiber.resume(runnable)
									}, 0)
									return fiber
								},
								onInterruptSignal = () => {
									if (!processAll) {
										target -= todos.length
										todos = []
									}
									interrupted = !0
									fibers.forEach(fiber => {
										fiber._scheduler.scheduleTask(() => {
											fiber.unsafeInterruptAsFork(parent.id())
										}, 0)
									})
								},
								stepOrExit = batching ? step : core_exit,
								processingFiber = runFiber(
									core_async(resume => {
										const pushResult = (res, index) => {
												if ("Blocked" === res._op) residual.push(res)
												else {
													results.push({ index, exit: res })
													"Failure" !== res._op ||
														interrupted ||
														onInterruptSignal()
												}
											},
											next = () => {
												if (todos.length > 0) {
													const a = todos.pop()
													let index = counter++
													const returnNextElement = () => {
															const a = todos.pop()
															index = counter++
															return core_flatMap(yieldNow(), () =>
																core_flatMap(
																	stepOrExit(restore(f(a, index))),
																	onRes,
																),
															)
														},
														onRes = res => {
															if (todos.length > 0) {
																pushResult(res, index)
																if (todos.length > 0) return returnNextElement()
															}
															return succeed(res)
														},
														todo = core_flatMap(
															stepOrExit(restore(f(a, index))),
															onRes,
														),
														fiber = runFiber(todo)
													startOrder.push(fiber)
													fibers.add(fiber)
													interrupted &&
														fiber._scheduler.scheduleTask(() => {
															fiber.unsafeInterruptAsFork(parent.id())
														}, 0)
													fiber.addObserver(wrapped => {
														let exit
														exit =
															"Failure" === wrapped._op
																? wrapped
																: wrapped.effect_instruction_i0
														joinOrder.push(fiber)
														fibers.delete(fiber)
														pushResult(exit, index)
														if (results.length === target)
															resume(
																succeed(
																	getOrElse(
																		exitCollectAll(collectExits(), {
																			parallel: !0,
																		}),
																		() => exitVoid,
																	),
																),
															)
														else if (
															residual.length + results.length ===
															target
														) {
															const requests = residual
																.map(blocked => blocked.effect_instruction_i0)
																.reduce(par)
															resume(
																succeed(
																	blocked(
																		requests,
																		forEachConcurrentDiscard(
																			[
																				getOrElse(
																					exitCollectAll(collectExits(), {
																						parallel: !0,
																					}),
																					() => exitVoid,
																				),
																				...residual.map(
																					blocked =>
																						blocked.effect_instruction_i1,
																				),
																			],
																			i => i,
																			batching,
																			!0,
																			n,
																		),
																	),
																),
															)
														} else next()
													})
												}
											}
										for (let i = 0; i < fibersCount; i++) next()
									}),
								)
							return core_asVoid(
								onExit(
									core_flatten(
										restore(
											(self =>
												core_zipLeft(
													core_flatten(self.await),
													self.inheritAll,
												))(processingFiber),
										),
									),
									exitMatch({
										onFailure: () => {
											onInterruptSignal()
											const target = residual.length + 1,
												concurrency = Math.min(
													"number" == typeof n ? n : residual.length,
													residual.length,
												),
												toPop = Array.from(residual)
											return core_async(cb => {
												const exits = []
												let count = 0,
													index = 0
												const check = (index, hitNext) => exit => {
														exits[index] = exit
														count++
														count === target &&
															cb(
																getOrThrow(
																	exitCollectAll(exits, { parallel: !0 }),
																),
															)
														toPop.length > 0 && hitNext && next()
													},
													next = () => {
														runFiber(toPop.pop(), !0).addObserver(
															check(index, !0),
														)
														index++
													}
												processingFiber.addObserver(check(index, !1))
												index++
												for (let i = 0; i < concurrency; i++) next()
											})
										},
										onSuccess: () =>
											forEachSequential(joinOrder, f => f.inheritAll),
									}),
								),
							)
						}),
					),
				),
			forEachParN = (self, n, f, batching) =>
				suspend(() => {
					const as = Array_fromIterable(self),
						array = new Array(as.length)
					return core_zipRight(
						forEachConcurrentDiscard(
							as,
							(a, i) => core_map(f(a, i), b => (array[i] = b)),
							batching,
							!1,
							n,
						),
						succeed(array),
					)
				}),
			fiberRuntime_forkDaemon = self =>
				forkWithScopeOverride(self, globalScope),
			unsafeForkUnstarted = (
				effect,
				parentFiber,
				parentRuntimeFlags,
				overrideScope = null,
			) =>
				unsafeMakeChildFiber(
					effect,
					parentFiber,
					parentRuntimeFlags,
					overrideScope,
				),
			unsafeMakeChildFiber = (
				effect,
				parentFiber,
				parentRuntimeFlags,
				overrideScope = null,
			) => {
				const childId = FiberId_unsafeMake(),
					parentFiberRefs = parentFiber.getFiberRefs(),
					childFiberRefs = forkAs(parentFiberRefs, childId),
					childFiber = new FiberRuntime(
						childId,
						childFiberRefs,
						parentRuntimeFlags,
					),
					childContext = getOrDefault(childFiberRefs, currentContext),
					supervisor = childFiber._supervisor
				supervisor.onStart(
					childContext,
					effect,
					Option_some(parentFiber),
					childFiber,
				)
				childFiber.addObserver(exit => supervisor.onEnd(exit, childFiber))
				;(null !== overrideScope
					? overrideScope
					: Function_pipe(
							parentFiber.getFiberRef(currentForkScopeOverride),
							getOrElse(() => parentFiber.scope()),
						)
				).add(parentRuntimeFlags, childFiber)
				return childFiber
			},
			forkWithScopeOverride = (self, scopeOverride) =>
				withFiberRuntime((parentFiber, parentStatus) =>
					succeed(
						((
							effect,
							parentFiber,
							parentRuntimeFlags,
							overrideScope = null,
						) => {
							const childFiber = unsafeMakeChildFiber(
								effect,
								parentFiber,
								parentRuntimeFlags,
								overrideScope,
							)
							childFiber.resume(effect)
							return childFiber
						})(self, parentFiber, parentStatus.runtimeFlags, scopeOverride),
					),
				),
			parallelFinalizers = self =>
				contextWithEffect(context =>
					match(Context_getOption(context, scopeTag), {
						onNone: () => self,
						onSome: scope => {
							switch (scope.strategy._tag) {
								case "Parallel":
									return self
								case "Sequential":
								case "ParallelN":
									return core_flatMap(
										scopeFork(scope, ExecutionStrategy_parallel),
										inner => scopeExtend(self, inner),
									)
							}
						},
					}),
				),
			parallelNFinalizers = parallelism => self =>
				contextWithEffect(context =>
					match(Context_getOption(context, scopeTag), {
						onNone: () => self,
						onSome: scope =>
							"ParallelN" === scope.strategy._tag &&
							scope.strategy.parallelism === parallelism
								? self
								: core_flatMap(
										scopeFork(scope, ExecutionStrategy_parallelN(parallelism)),
										inner => scopeExtend(self, inner),
									),
					}),
				),
			finalizersMask = strategy => self =>
				contextWithEffect(context =>
					match(Context_getOption(context, scopeTag), {
						onNone: () => self(Function_identity),
						onSome: scope => {
							const patch =
								"Parallel" === strategy._tag
									? parallelFinalizers
									: "Sequential" === strategy._tag
										? sequentialFinalizers
										: parallelNFinalizers(strategy.parallelism)
							switch (scope.strategy._tag) {
								case "Parallel":
									return patch(self(parallelFinalizers))
								case "Sequential":
									return patch(self(sequentialFinalizers))
								case "ParallelN":
									return patch(
										self(parallelNFinalizers(scope.strategy.parallelism)),
									)
							}
						},
					}),
				),
			sequentialFinalizers = self =>
				contextWithEffect(context =>
					match(Context_getOption(context, scopeTag), {
						onNone: () => self,
						onSome: scope => {
							switch (scope.strategy._tag) {
								case "Sequential":
									return self
								case "Parallel":
								case "ParallelN":
									return core_flatMap(
										scopeFork(scope, ExecutionStrategy_sequential),
										inner => scopeExtend(self, inner),
									)
							}
						},
					}),
				),
			zipLeftOptions = Function_dual(
				args => isEffect(args[1]),
				(self, that, options) =>
					!0 === options?.concurrent ||
					(void 0 !== options?.batching && !1 !== options.batching)
						? zipWithOptions(self, that, (a, _) => a, options)
						: core_zipLeft(self, that),
			),
			zipRightOptions = Function_dual(
				args => isEffect(args[1]),
				(self, that, options) =>
					!0 === options?.concurrent ||
					(void 0 !== options?.batching && !1 !== options.batching)
						? zipWithOptions(self, that, (_, b) => b, options)
						: core_zipRight(self, that),
			),
			zipWithOptions = Function_dual(
				args => isEffect(args[1]),
				(self, that, f, options) =>
					core_map(
						fiberRuntime_all([self, that], {
							concurrency: options?.concurrent ? 2 : 1,
							batching: options?.batching,
						}),
						([a, a2]) => f(a, a2),
					),
			),
			scopeTag = GenericTag("effect/Scope"),
			fiberRuntime_scope = scopeTag,
			ScopeImplProto = {
				[ScopeTypeId]: ScopeTypeId,
				[CloseableScopeTypeId]: CloseableScopeTypeId,
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
				fork(strategy) {
					return sync(() => {
						const newScope = fiberRuntime_scopeUnsafeMake(strategy)
						if ("Closed" === this.state._tag) {
							newScope.state = this.state
							return newScope
						}
						const fin = exit => newScope.close(exit)
						this.state.finalizers.add(fin)
						;((scope, fin) => {
							"Open" === scope.state._tag && scope.state.finalizers.add(fin)
						})(newScope, _ =>
							sync(() => {
								"Open" === this.state._tag && this.state.finalizers.delete(fin)
							}),
						)
						return newScope
					})
				},
				close(exit) {
					return suspend(() => {
						if ("Closed" === this.state._tag) return core_void_
						const finalizers = Array.from(
							this.state.finalizers.values(),
						).reverse()
						this.state = { _tag: "Closed", exit }
						return 0 === finalizers.length
							? core_void_
							: (self => "Sequential" === this.strategy._tag)()
								? Function_pipe(
										forEachSequential(finalizers, fin => core_exit(fin(exit))),
										core_flatMap(results =>
											Function_pipe(
												exitCollectAll(results),
												map(exitAsVoid),
												getOrElse(() => exitVoid),
											),
										),
									)
								: (self => "Parallel" === this.strategy._tag)()
									? Function_pipe(
											forEachParUnbounded(
												finalizers,
												fin => core_exit(fin(exit)),
												!1,
											),
											core_flatMap(results =>
												Function_pipe(
													exitCollectAll(results, { parallel: !0 }),
													map(exitAsVoid),
													getOrElse(() => exitVoid),
												),
											),
										)
									: Function_pipe(
											forEachParN(
												finalizers,
												this.strategy.parallelism,
												fin => core_exit(fin(exit)),
												!1,
											),
											core_flatMap(results =>
												Function_pipe(
													exitCollectAll(results, { parallel: !0 }),
													map(exitAsVoid),
													getOrElse(() => exitVoid),
												),
											),
										)
					})
				},
				addFinalizer(fin) {
					return suspend(() => {
						if ("Closed" === this.state._tag) return fin(this.state.exit)
						this.state.finalizers.add(fin)
						return core_void_
					})
				},
			},
			fiberRuntime_scopeUnsafeMake = (
				strategy = executionStrategy_sequential,
			) => {
				const scope = Object.create(ScopeImplProto)
				scope.strategy = strategy
				scope.state = { _tag: "Open", finalizers: new Set() }
				return scope
			},
			fiberRuntime_scopeMake = (strategy = executionStrategy_sequential) =>
				sync(() => fiberRuntime_scopeUnsafeMake(strategy)),
			scopeExtend = Function_dual(2, (effect, scope) =>
				mapInputContext(effect, Context_merge(Context_make(scopeTag, scope))),
			),
			fiberRefUnsafeMakeSupervisor = initial =>
				fiberRefUnsafeMakePatch(initial, {
					differ: patch_differ,
					fork: supervisor_patch_empty,
				}),
			fiberRefLocallyScoped = Function_dual(2, (self, value) =>
				core_asVoid(
					fiberRuntime_acquireRelease(
						core_flatMap(fiberRefGet(self), oldValue =>
							core_as(fiberRefSet(self, value), oldValue),
						),
						oldValue => fiberRefSet(self, oldValue),
					),
				),
			),
			fiberRefLocallyScopedWith = Function_dual(2, (self, f) =>
				fiberRefGetWith(self, a => fiberRefLocallyScoped(self, f(a))),
			),
			currentRuntimeFlags = fiberRefUnsafeMakeRuntimeFlags(runtimeFlags_none),
			currentSupervisor = fiberRefUnsafeMakeSupervisor(supervisor_none),
			fiberRuntime_ensuring = Function_dual(2, (self, finalizer) =>
				uninterruptibleMask(restore =>
					matchCauseEffect(restore(self), {
						onFailure: cause1 =>
							matchCauseEffect(finalizer, {
								onFailure: cause2 => failCause(sequential(cause1, cause2)),
								onSuccess: () => failCause(cause1),
							}),
						onSuccess: a => core_as(finalizer, a),
					}),
				),
			),
			invokeWithInterrupt = (self, entries, onInterrupt) =>
				fiberIdWith(id =>
					core_flatMap(
						core_flatMap(
							fiberRuntime_forkDaemon(core_interruptible(self)),
							processing =>
								core_async(cb => {
									const counts = entries.map(_ => _.listeners.count),
										checkDone = () => {
											if (
												counts.every(count => 0 === count) &&
												entries.every(
													_ =>
														"Pending" === _.result.state.current._tag ||
														!(
															"Done" !== _.result.state.current._tag ||
															!exitIsExit(_.result.state.current.effect) ||
															"Failure" !==
																_.result.state.current.effect._tag ||
															!(self =>
																Option_isSome(
																	(self =>
																		find(self, cause =>
																			"Interrupt" === cause._tag
																				? Option_some(cause.fiberId)
																				: Option_none(),
																		))(self),
																))(_.result.state.current.effect.cause)
														),
												)
											) {
												cleanup.forEach(f => f())
												onInterrupt?.()
												cb(
													(self =>
														core_flatMap(fiberId, fiberId =>
															Function_pipe(self, interruptAsFiber(fiberId)),
														))(processing),
												)
											}
										}
									processing.addObserver(exit => {
										cleanup.forEach(f => f())
										cb(exit)
									})
									const cleanup = entries.map((r, i) => {
										const observer = count => {
											counts[i] = count
											checkDone()
										}
										r.listeners.addObserver(observer)
										return () => r.listeners.removeObserver(observer)
									})
									checkDone()
									return sync(() => {
										cleanup.forEach(f => f())
									})
								}),
						),
						() =>
							suspend(() => {
								const residual = entries.flatMap(entry =>
									entry.state.completed ? [] : [entry],
								)
								return forEachSequentialDiscard(residual, entry =>
									request_complete(
										entry.request,
										(fiberId => exitFailCause(interrupt(fiberId)))(id),
									),
								)
							}),
					),
				),
			Cause_fail = fail,
			Cause_failureOrCause = failureOrCause,
			Cause_NoSuchElementException = NoSuchElementException,
			Cause_pretty = pretty,
			String_Equivalence = Equivalence_string,
			String_isEmpty = self => 0 === self.length,
			String_isNonEmpty = self => self.length > 0,
			String_split = Function_dual(2, (self, separator) => {
				const out = self.split(separator)
				return isNonEmptyArray(out) ? out : [self]
			})
		Symbol.iterator
		const IntervalTypeId = Symbol.for("effect/ScheduleInterval"),
			interval_empty = {
				[IntervalTypeId]: IntervalTypeId,
				startMillis: 0,
				endMillis: 0,
			},
			ScheduleInterval_empty = interval_empty,
			ScheduleInterval_after = startMilliseconds => {
				return (startMillis = startMilliseconds) >
					(endMillis = Number.POSITIVE_INFINITY)
					? interval_empty
					: { [IntervalTypeId]: IntervalTypeId, startMillis, endMillis }
				var startMillis, endMillis
			},
			IntervalsTypeId = Symbol.for("effect/ScheduleIntervals"),
			ScheduleDecision_continueWith = interval => {
				return {
					_tag: "Continue",
					intervals:
						((intervals = Chunk_of(interval)),
						{ [IntervalsTypeId]: IntervalsTypeId, intervals }),
				}
				var intervals
			},
			ScheduleTypeId = Symbol.for("effect/Schedule"),
			ScheduleDriverTypeId = Symbol.for("effect/ScheduleDriver"),
			scheduleVariance = { _Out: _ => _, _In: _ => _, _R: _ => _ },
			scheduleDriverVariance = { _Out: _ => _, _In: _ => _, _R: _ => _ }
		class ScheduleImpl {
			initial
			step;
			[ScheduleTypeId] = scheduleVariance
			constructor(initial, step) {
				this.initial = initial
				this.step = step
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		class ScheduleDriverImpl {
			schedule
			ref;
			[ScheduleDriverTypeId] = scheduleDriverVariance
			constructor(schedule, ref) {
				this.schedule = schedule
				this.ref = ref
			}
			get state() {
				return core_map(ref_get(this.ref), tuple => tuple[1])
			}
			get last() {
				return core_flatMap(ref_get(this.ref), ([element, _]) => {
					switch (element._tag) {
						case "None":
							return failSync(() => new NoSuchElementException())
						case "Some":
							return succeed(element.value)
					}
				})
			}
			get reset() {
				return ref_set(this.ref, [Option_none(), this.schedule.initial])
			}
			next(input) {
				return Function_pipe(
					core_map(ref_get(this.ref), tuple => tuple[1]),
					core_flatMap(state =>
						Function_pipe(
							Clock_currentTimeMillis,
							core_flatMap(now =>
								Function_pipe(
									suspend(() => this.schedule.step(now, input, state)),
									core_flatMap(([state, out, decision]) => {
										const setState = ref_set(this.ref, [
											Option_some(out),
											state,
										])
										if ((self => "Done" === self._tag)(decision))
											return core_zipRight(setState, core_fail(Option_none()))
										const millis =
											(self =>
												Function_pipe(
													self.intervals,
													Chunk_head,
													getOrElse(() => ScheduleInterval_empty),
												).startMillis)(decision.intervals) - now
										return millis <= 0
											? core_as(setState, out)
											: Function_pipe(
													setState,
													core_zipRight(
														(duration => {
															const decodedDuration = decode(duration)
															return clockWith(clock =>
																clock.sleep(decodedDuration),
															)
														})(Duration_millis(millis)),
													),
													core_as(out),
												)
									}),
								),
							),
						),
					),
				)
			}
		}
		const schedule_Effect = Function_dual(2, (self, schedule) =>
				scheduleFrom_Effect(self, void 0, schedule),
			),
			scheduleFrom_Effect = Function_dual(3, (self, initial, schedule) =>
				core_flatMap(
					(self =>
						Function_pipe(
							ref_make([Option_none(), self.initial]),
							core_map(ref => new ScheduleDriverImpl(self, ref)),
						))(schedule),
					driver => scheduleFrom_EffectLoop(self, initial, driver),
				),
			),
			scheduleFrom_EffectLoop = (self, initial, driver) =>
				matchEffect(driver.next(initial), {
					onFailure: () =>
						(self => orDieWith(self, Function_identity))(driver.last),
					onSuccess: () =>
						core_flatMap(self, a => scheduleFrom_EffectLoop(self, a, driver)),
				})
		class Semaphore {
			permits
			waiters = new Set()
			taken = 0
			constructor(permits) {
				this.permits = permits
			}
			get free() {
				return this.permits - this.taken
			}
			take = n =>
				core_async(resume => {
					if (this.free < n) {
						const observer = () => {
							if (!(this.free < n)) {
								this.waiters.delete(observer)
								this.taken += n
								resume(succeed(n))
							}
						}
						this.waiters.add(observer)
						return sync(() => {
							this.waiters.delete(observer)
						})
					}
					this.taken += n
					return resume(succeed(n))
				})
			updateTaken = f =>
				withFiberRuntime(fiber => {
					this.taken = f(this.taken)
					this.waiters.size > 0 &&
						fiber.getFiberRef(currentScheduler).scheduleTask(() => {
							const iter = this.waiters.values()
							let item = iter.next()
							for (; !1 === item.done && this.free > 0; ) {
								item.value()
								item = iter.next()
							}
						}, fiber.getFiberRef(currentSchedulingPriority))
					return succeed(this.free)
				})
			release = n => this.updateTaken(taken => taken - n)
			releaseAll = this.updateTaken(_ => 0)
			withPermits = n => self =>
				uninterruptibleMask(restore =>
					core_flatMap(restore(this.take(n)), permits =>
						fiberRuntime_ensuring(restore(self), this.release(permits)),
					),
				)
		}
		const SynchronizedTypeId = Symbol.for("effect/Ref/SynchronizedRef"),
			synchronizedVariance = { _A: _ => _ }
		class SynchronizedImpl {
			ref
			withLock;
			[SynchronizedTypeId] = synchronizedVariance;
			[RefTypeId] = refVariance;
			[Readable_TypeId]
			constructor(ref, withLock) {
				this.ref = ref
				this.withLock = withLock
				this[Readable_TypeId] = Readable_TypeId
				this.get = ref_get(this.ref)
			}
			get;
			modify(f) {
				return this.modifyEffect(a => succeed(f(a)))
			}
			modifyEffect(f) {
				return this.withLock(
					Function_pipe(
						core_flatMap(ref_get(this.ref), f),
						core_flatMap(([b, a]) => core_as(ref_set(this.ref, a), b)),
					),
				)
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const makeSynchronized = value => sync(() => unsafeMakeSynchronized(value)),
			unsafeMakeSynchronized = value => {
				const ref = ref_unsafeMake(value),
					sem = new Semaphore(1)
				return new SynchronizedImpl(ref, sem.withPermits(1))
			},
			Scope_close = scopeClose,
			Scope_fork = scopeFork,
			runtime_unsafeFork = runtime => (self, options) => {
				const fiberId = FiberId_unsafeMake(),
					fiberRefUpdates = [[currentContext, [[fiberId, runtime.context]]]]
				options?.scheduler &&
					fiberRefUpdates.push([
						currentScheduler,
						[[fiberId, options.scheduler]],
					])
				let fiberRefs = FiberRefs_updateManyAs(runtime.fiberRefs, {
					entries: fiberRefUpdates,
					forkAs: fiberId,
				})
				options?.updateRefs &&
					(fiberRefs = options.updateRefs(fiberRefs, fiberId))
				const fiberRuntime = new FiberRuntime(
					fiberId,
					fiberRefs,
					runtime.runtimeFlags,
				)
				let effect = self
				options?.scope &&
					(effect = core_flatMap(
						Scope_fork(options.scope, executionStrategy_sequential),
						closeableScope =>
							core_zipRight(
								((self, finalizer) =>
									self.addFinalizer(() => core_asVoid(finalizer)))(
									closeableScope,
									fiberIdWith(id =>
										equals(id, fiberRuntime.id())
											? core_void_
											: interruptAsFiber(fiberRuntime, id),
									),
								),
								onExit(self, exit => Scope_close(closeableScope, exit)),
							),
					))
				const supervisor = fiberRuntime._supervisor
				if (supervisor !== supervisor_none) {
					supervisor.onStart(
						runtime.context,
						effect,
						Option_none(),
						fiberRuntime,
					)
					fiberRuntime.addObserver(exit => supervisor.onEnd(exit, fiberRuntime))
				}
				globalScope.add(runtime.runtimeFlags, fiberRuntime)
				!1 === options?.immediate
					? fiberRuntime.resume(effect)
					: fiberRuntime.start(effect)
				return fiberRuntime
			},
			unsafeRunSync = runtime => effect => {
				const result = unsafeRunSyncExit(runtime)(effect)
				if ("Failure" === result._tag)
					throw fiberFailure(result.effect_instruction_i0)
				return result.effect_instruction_i0
			}
		class AsyncFiberExceptionImpl extends Error {
			fiber
			_tag = "AsyncFiberException"
			constructor(fiber) {
				super(
					`Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`,
				)
				this.fiber = fiber
				this.name = this._tag
				this.stack = this.message
			}
		}
		const FiberFailureId = Symbol.for("effect/Runtime/FiberFailure"),
			FiberFailureCauseId = Symbol.for("effect/Runtime/FiberFailure/Cause")
		class FiberFailureImpl extends Error {
			[FiberFailureId];
			[FiberFailureCauseId]
			constructor(cause) {
				super()
				this[FiberFailureId] = FiberFailureId
				this[FiberFailureCauseId] = cause
				const prettyErrors = cause_prettyErrors(cause)
				if (prettyErrors.length > 0) {
					const head = prettyErrors[0]
					this.name = head.name
					this.message = head.message
					this.stack = head.stack
				}
				this.name = `(FiberFailure) ${this.name}`
				;(void 0 !== this.message && 0 !== this.message.length) ||
					(this.message = "An error has occurred")
			}
			toJSON() {
				return {
					_id: "FiberFailure",
					cause: this[FiberFailureCauseId].toJSON(),
				}
			}
			toString() {
				return "(FiberFailure) " + (this.stack ?? this.message)
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toString()
			}
		}
		const fiberFailure = cause => {
				const limit = Error.stackTraceLimit
				Error.stackTraceLimit = 0
				const error = new FiberFailureImpl(cause)
				Error.stackTraceLimit = limit
				return error
			},
			fastPath = effect => {
				const op = effect
				switch (op._op) {
					case "Failure":
					case "Success":
						return op
					case "Left":
						return exitFail(op.left)
					case "Right":
						return exitSucceed(op.right)
					case "Some":
						return exitSucceed(op.value)
					case "None":
						return exitFail(NoSuchElementException())
				}
			},
			unsafeRunSyncExit = runtime => effect => {
				const op = fastPath(effect)
				if (op) return op
				const scheduler = new SyncScheduler(),
					fiberRuntime = runtime_unsafeFork(runtime)(effect, { scheduler })
				scheduler.flush()
				const result = fiberRuntime.unsafePoll()
				if (result) return result
				throw (fiber => {
					const limit = Error.stackTraceLimit
					Error.stackTraceLimit = 0
					const error = new AsyncFiberExceptionImpl(fiber)
					Error.stackTraceLimit = limit
					return error
				})(fiberRuntime)
			},
			unsafeRunPromise = runtime => (effect, options) =>
				unsafeRunPromiseExit(runtime)(effect, options).then(result => {
					switch (result._tag) {
						case "Success":
							return result.effect_instruction_i0
						case "Failure":
							throw fiberFailure(result.effect_instruction_i0)
					}
				}),
			unsafeRunPromiseExit = runtime => (effect, options) =>
				new Promise(resolve => {
					const op = fastPath(effect)
					op && resolve(op)
					const fiber = runtime_unsafeFork(runtime)(effect)
					fiber.addObserver(exit => {
						resolve(exit)
					})
					void 0 !== options?.signal &&
						(options.signal.aborted
							? fiber.unsafeInterruptAsFork(fiber.id())
							: options.signal.addEventListener(
									"abort",
									() => {
										fiber.unsafeInterruptAsFork(fiber.id())
									},
									{ once: !0 },
								))
				})
		class RuntimeImpl {
			context
			runtimeFlags
			fiberRefs
			constructor(context, runtimeFlags, fiberRefs) {
				this.context = context
				this.runtimeFlags = runtimeFlags
				this.fiberRefs = fiberRefs
			}
			pipe() {
				return Pipeable_pipeArguments(this, arguments)
			}
		}
		const runtime_make = options =>
				new RuntimeImpl(
					options.context,
					options.runtimeFlags,
					options.fiberRefs,
				),
			defaultRuntimeFlags = runtimeFlags_make(1, 32, 4),
			defaultRuntime = runtime_make({
				context: Context_empty(),
				runtimeFlags: defaultRuntimeFlags,
				fiberRefs: FiberRefs_empty(),
			}),
			unsafeRunPromiseEffect = unsafeRunPromise(defaultRuntime),
			unsafeRunSyncEffect = unsafeRunSync(defaultRuntime),
			modifyEffect = Function_dual(2, (self, f) => self.modifyEffect(f)),
			LayerTypeId = Symbol.for("effect/Layer"),
			layer_proto = {
				[LayerTypeId]: { _RIn: _ => _, _E: _ => _, _ROut: _ => _ },
				pipe() {
					return Pipeable_pipeArguments(this, arguments)
				},
			},
			MemoMapTypeId = Symbol.for("effect/Layer/MemoMap"),
			isFresh = self => "Fresh" === self._tag
		class MemoMapImpl {
			ref;
			[MemoMapTypeId]
			constructor(ref) {
				this.ref = ref
				this[MemoMapTypeId] = MemoMapTypeId
			}
			getOrElseMemoize(layer, scope) {
				return Function_pipe(
					modifyEffect(this.ref, map => {
						const inMap = map.get(layer)
						if (void 0 !== inMap) {
							const [acquire, release] = inMap,
								cached = Function_pipe(
									acquire,
									core_flatMap(([patch, b]) =>
										Function_pipe(
											(patch => {
												return (
													(f = (fiberId, fiberRefs) =>
														Function_pipe(
															patch,
															patch_patch(fiberId, fiberRefs),
														)),
													withFiberRuntime(state => {
														state.setFiberRefs(
															f(state.id(), state.getFiberRefs()),
														)
														return core_void_
													})
												)
												var f
											})(patch),
											core_as(b),
										),
									),
									onExit(
										exitMatch({
											onFailure: () => core_void_,
											onSuccess: () => scopeAddFinalizerExit(scope, release),
										}),
									),
								)
							return succeed([cached, map])
						}
						return Function_pipe(
							ref_make(0),
							core_flatMap(observers =>
								Function_pipe(
									core_flatMap(fiberId, id =>
										(fiberId => sync(() => deferredUnsafeMake(fiberId)))(id),
									),
									core_flatMap(deferred =>
										Function_pipe(
											ref_make(() => core_void_),
											core_map(finalizerRef => {
												const resource = uninterruptibleMask(restore =>
														Function_pipe(
															fiberRuntime_scopeMake(),
															core_flatMap(innerScope =>
																Function_pipe(
																	restore(
																		core_flatMap(
																			makeBuilder(layer, innerScope, !0),
																			f =>
																				(self =>
																					summarized(
																						self,
																						core_effect_fiberRefs,
																						patch_diff,
																					))(f(this)),
																		),
																	),
																	core_exit,
																	core_flatMap(exit => {
																		switch (exit._tag) {
																			case "Failure":
																				return Function_pipe(
																					deferredFailCause(
																						deferred,
																						exit.effect_instruction_i0,
																					),
																					core_zipRight(
																						scopeClose(innerScope, exit),
																					),
																					core_zipRight(
																						failCause(
																							exit.effect_instruction_i0,
																						),
																					),
																				)
																			case "Success":
																				return Function_pipe(
																					ref_set(finalizerRef, exit =>
																						Function_pipe(
																							scopeClose(innerScope, exit),
																							whenEffect(
																								ref_modify(observers, n => [
																									1 === n,
																									n - 1,
																								]),
																							),
																							core_asVoid,
																						),
																					),
																					core_zipRight(
																						ref_update(observers, n => n + 1),
																					),
																					core_zipRight(
																						scopeAddFinalizerExit(scope, exit =>
																							Function_pipe(
																								sync(() => map.delete(layer)),
																								core_zipRight(
																									ref_get(finalizerRef),
																								),
																								core_flatMap(finalizer =>
																									finalizer(exit),
																								),
																							),
																						),
																					),
																					core_zipRight(
																						deferredSucceed(
																							deferred,
																							exit.effect_instruction_i0,
																						),
																					),
																					core_as(
																						exit.effect_instruction_i0[1],
																					),
																				)
																		}
																	}),
																),
															),
														),
													),
													memoized = [
														Function_pipe(
															deferredAwait(deferred),
															onExit(
																exitMatchEffect({
																	onFailure: () => core_void_,
																	onSuccess: () =>
																		ref_update(observers, n => n + 1),
																}),
															),
														),
														exit =>
															Function_pipe(
																ref_get(finalizerRef),
																core_flatMap(finalizer => finalizer(exit)),
															),
													]
												return [
													resource,
													isFresh(layer) ? map : map.set(layer, memoized),
												]
											}),
										),
									),
								),
							),
						)
					}),
					core_flatten,
				)
			}
		}
		const makeMemoMap = suspend(() =>
				core_map(makeSynchronized(new Map()), ref => new MemoMapImpl(ref)),
			),
			buildWithScope = Function_dual(2, (self, scope) =>
				core_flatMap(makeMemoMap, memoMap =>
					core_flatMap(makeBuilder(self, scope), run => run(memoMap)),
				),
			),
			makeBuilder = (self, scope, inMemoMap = !1) => {
				const op = self
				switch (op._tag) {
					case "Locally":
						return sync(
							() => memoMap => op.f(memoMap.getOrElseMemoize(op.self, scope)),
						)
					case "ExtendScope":
						return sync(() => memoMap => {
							return (
								(f = scope => memoMap.getOrElseMemoize(op.layer, scope)),
								core_flatMap(scopeTag, f)
							)
							var f
						})
					case "Fold":
						return sync(
							() => memoMap =>
								Function_pipe(
									memoMap.getOrElseMemoize(op.layer, scope),
									matchCauseEffect({
										onFailure: cause =>
											memoMap.getOrElseMemoize(op.failureK(cause), scope),
										onSuccess: value =>
											memoMap.getOrElseMemoize(op.successK(value), scope),
									}),
								),
						)
					case "Fresh":
						return sync(
							() => _ => Function_pipe(op.layer, buildWithScope(scope)),
						)
					case "FromEffect":
						return sync(
							inMemoMap
								? () => _ => op.effect
								: () => memoMap => memoMap.getOrElseMemoize(self, scope),
						)
					case "Provide":
						return sync(
							() => memoMap =>
								Function_pipe(
									memoMap.getOrElseMemoize(op.first, scope),
									core_flatMap(env =>
										Function_pipe(
											memoMap.getOrElseMemoize(op.second, scope),
											provideContext(env),
										),
									),
								),
						)
					case "Scoped":
						return sync(
							inMemoMap
								? () => _ => scopeExtend(op.effect, scope)
								: () => memoMap => memoMap.getOrElseMemoize(self, scope),
						)
					case "Suspend":
						return sync(
							() => memoMap => memoMap.getOrElseMemoize(op.evaluate(), scope),
						)
					case "ProvideMerge":
						return sync(
							() => memoMap =>
								Function_pipe(
									memoMap.getOrElseMemoize(op.first, scope),
									core_zipWith(
										memoMap.getOrElseMemoize(op.second, scope),
										op.zipK,
									),
								),
						)
					case "ZipWith":
						return sync(
							() => memoMap =>
								Function_pipe(
									memoMap.getOrElseMemoize(op.first, scope),
									zipWithOptions(
										memoMap.getOrElseMemoize(op.second, scope),
										op.zipK,
										{ concurrent: !0 },
									),
								),
						)
				}
			},
			layer_fail = error => layer_failCause(Cause_fail(error)),
			layer_failCause = cause =>
				(function (effect) {
					const fromEffect = Object.create(layer_proto)
					fromEffect._tag = "FromEffect"
					fromEffect.effect = effect
					return fromEffect
				})(failCause(cause)),
			layer_flatMap = Function_dual(2, (self, f) =>
				layer_match(self, { onFailure: layer_fail, onSuccess: f }),
			),
			layer_matchCause = Function_dual(2, (self, { onFailure, onSuccess }) => {
				const fold = Object.create(layer_proto)
				fold._tag = "Fold"
				fold.layer = self
				fold.failureK = onFailure
				fold.successK = onSuccess
				return fold
			}),
			layer_match = Function_dual(2, (self, { onFailure, onSuccess }) =>
				layer_matchCause(self, {
					onFailure: cause => {
						const failureOrCause = Cause_failureOrCause(cause)
						switch (failureOrCause._tag) {
							case "Left":
								return onFailure(failureOrCause.left)
							case "Right":
								return layer_failCause(failureOrCause.right)
						}
					},
					onSuccess,
				}),
			),
			scopedDiscard = effect =>
				scopedContext(Function_pipe(effect, core_as(Context_empty()))),
			scopedContext = effect => {
				const scoped = Object.create(layer_proto)
				scoped._tag = "Scoped"
				scoped.effect = effect
				return scoped
			},
			provideSomeLayer = Function_dual(2, (self, layer) =>
				acquireUseRelease(
					fiberRuntime_scopeMake(),
					scope =>
						core_flatMap(buildWithScope(layer, scope), context =>
							provideSomeContext(self, context),
						),
					(scope, exit) => scopeClose(scope, exit),
				),
			),
			provideSomeRuntime = Function_dual(2, (self, rt) => {
				const patchRefs = FiberRefsPatch_diff(
						defaultRuntime.fiberRefs,
						rt.fiberRefs,
					),
					patchFlags = runtimeFlags_diff(
						defaultRuntime.runtimeFlags,
						rt.runtimeFlags,
					)
				return uninterruptibleMask(restore =>
					withFiberRuntime(fiber => {
						const oldContext = fiber.getFiberRef(currentContext),
							oldRefs = fiber.getFiberRefs(),
							newRefs = FiberRefsPatch_patch(fiber.id(), oldRefs)(patchRefs),
							oldFlags = fiber._runtimeFlags,
							newFlags = runtimeFlags_patch(patchFlags)(oldFlags),
							rollbackRefs = FiberRefsPatch_diff(newRefs, oldRefs),
							rollbackFlags = runtimeFlags_diff(newFlags, oldFlags)
						fiber.setFiberRefs(newRefs)
						fiber._runtimeFlags = newFlags
						return fiberRuntime_ensuring(
							provideSomeContext(
								restore(self),
								Context_merge(oldContext, rt.context),
							),
							withFiberRuntime(fiber => {
								fiber.setFiberRefs(
									FiberRefsPatch_patch(
										fiber.id(),
										fiber.getFiberRefs(),
									)(rollbackRefs),
								)
								fiber._runtimeFlags = runtimeFlags_patch(rollbackFlags)(
									fiber._runtimeFlags,
								)
								return core_void_
							}),
						)
					}),
				)
			}),
			effect_provide = Function_dual(2, (self, source) =>
				(u => Predicate_hasProperty(u, LayerTypeId))(source)
					? provideSomeLayer(self, source)
					: Context_isContext(source)
						? provideSomeContext(self, source)
						: provideSomeRuntime(self, source),
			),
			consoleWith = f =>
				fiberRefGetWith(currentServices, services =>
					f(Context_get(services, consoleTag)),
				)
		Symbol.iterator
		Symbol.iterator
		const Effect_isEffect = isEffect,
			Effect_all = fiberRuntime_all,
			Effect_allSuccesses = (elements, options) =>
				core_map(
					fiberRuntime_all(
						Array_fromIterable(elements).map(core_exit),
						options,
					),
					Array_filterMap(exit =>
						(self => "Success" === self._tag)(exit)
							? Option_some(exit.effect_instruction_i0)
							: Option_none(),
					),
				),
			Effect_forEach = fiberRuntime_forEach,
			Effect_fail = core_fail,
			Effect_gen = function () {
				let f
				f =
					1 === arguments.length
						? arguments[0]
						: arguments[1].bind(arguments[0])
				return suspend(() => {
					const iterator = f(Function_pipe),
						state = internalCall(() => iterator.next()),
						run = state =>
							state.done
								? succeed(state.value)
								: core_flatMap(
										(function (self) {
											if (
												"object" == typeof self &&
												null !== self &&
												YieldWrapTypeId in self
											)
												return self[YieldWrapTypeId]()
											throw new Error(getBugErrorMessage("yieldWrapGet"))
										})(state.value),
										val => run(internalCall(() => iterator.next(val))),
									)
					return run(state)
				})
			},
			Effect_promise = evaluate =>
				evaluate.length >= 1
					? core_async((resolve, signal) => {
							evaluate(signal).then(
								a => resolve(exitSucceed(a)),
								e => resolve(exitDie(e)),
							)
						})
					: core_async(resolve => {
							evaluate().then(
								a => resolve(exitSucceed(a)),
								e => resolve(exitDie(e)),
							)
						}),
			Effect_succeed = succeed,
			Effect_suspend = suspend,
			Effect_sync = sync,
			_void = core_void_,
			Effect_catchAll = catchAll,
			Effect_ignore = self =>
				core_effect_match(self, {
					onFailure: Function_constVoid,
					onSuccess: Function_constVoid,
				}),
			Effect_map = core_map,
			Effect_mapError = mapError,
			Effect_forkDaemon = fiberRuntime_forkDaemon,
			Effect_withConcurrency = withConcurrency,
			Effect_provide = effect_provide,
			Effect_either = core_either,
			Effect_option = self =>
				matchEffect(self, {
					onFailure: () => succeed(Option_none()),
					onSuccess: a => succeed(Option_some(a)),
				}),
			Effect_filterOrElse = filterOrElse,
			Effect_filterOrFail = core_effect_filterOrFail,
			Effect_when = core_effect_when,
			Effect_flatMap = core_flatMap,
			Effect_tap = core_tap,
			Effect_tapErrorCause = core_effect_tapErrorCause,
			schedule = schedule_Effect,
			Effect_locally = fiberRefLocally,
			Effect_isSuccess = self =>
				core_effect_match(self, {
					onFailure: constFalse,
					onSuccess: Function_constTrue,
				}),
			Effect_matchEffect = matchEffect,
			Effect_log = log,
			Effect_logDebug = logDebug,
			Effect_logInfo = logInfo,
			Effect_logWarning = logWarning,
			Effect_logError = logError,
			Effect_annotateLogs = annotateLogs,
			Effect_orElse = core_orElse,
			Effect_orElseSucceed = core_effect_orElseSucceed,
			Effect_runPromise = unsafeRunPromiseEffect,
			Effect_runSync = unsafeRunSyncEffect,
			Effect_zipLeft = zipLeftOptions,
			Effect_zipRight = zipRightOptions,
			Effect_fromNullable = value =>
				null == value
					? core_fail(new NoSuchElementException())
					: succeed(value),
			external_rxjs_namespaceObject = rxjs,
			lib = observer => value => {
				observer.next(value)
			}
		var EMPTY_OBJ = {},
			EMPTY_ARR = [],
			hyperapp_id = a => a,
			hyperapp_map = EMPTY_ARR.map,
			hyperapp_isArray = Array.isArray,
			enqueue =
				"undefined" != typeof requestAnimationFrame
					? requestAnimationFrame
					: setTimeout,
			createClass = obj => {
				var out = ""
				if ("string" == typeof obj) return obj
				if (hyperapp_isArray(obj))
					for (var tmp, k = 0; k < obj.length; k++)
						(tmp = createClass(obj[k])) && (out += (out && " ") + tmp)
				else for (var k in obj) obj[k] && (out += (out && " ") + k)
				return out
			},
			shouldRestart = (a, b) => {
				for (var k in { ...a, ...b })
					if ("function" == typeof (hyperapp_isArray(a[k]) ? a[k][0] : a[k]))
						b[k] = a[k]
					else if (a[k] !== b[k]) return !0
			},
			getKey = vdom => (null == vdom ? vdom : vdom.key),
			patchProperty = (node, key, oldValue, newValue, listener, isSvg) => {
				if ("style" === key)
					for (var k in { ...oldValue, ...newValue }) {
						oldValue =
							null == newValue || null == newValue[k] ? "" : newValue[k]
						"-" === k[0]
							? node[key].setProperty(k, oldValue)
							: (node[key][k] = oldValue)
					}
				else
					"o" === key[0] && "n" === key[1]
						? ((node.events || (node.events = {}))[(key = key.slice(2))] =
								newValue)
							? oldValue || node.addEventListener(key, listener)
							: node.removeEventListener(key, listener)
						: !isSvg && "list" !== key && "form" !== key && key in node
							? (node[key] = newValue ?? "")
							: null == newValue || !1 === newValue
								? node.removeAttribute(key)
								: node.setAttribute(key, newValue)
			},
			createNode = (vdom, listener, isSvg) => {
				var props = vdom.props,
					node =
						3 === vdom.type
							? document.createTextNode(vdom.tag)
							: (isSvg = isSvg || "svg" === vdom.tag)
								? document.createElementNS(
										"http://www.w3.org/2000/svg",
										vdom.tag,
										props.is && props,
									)
								: document.createElement(vdom.tag, props.is && props)
				for (var k in props)
					patchProperty(node, k, null, props[k], listener, isSvg)
				for (var i = 0; i < vdom.children.length; i++)
					node.appendChild(
						createNode(
							(vdom.children[i] = maybeVNode(vdom.children[i])),
							listener,
							isSvg,
						),
					)
				return (vdom.node = node)
			},
			hyperapp_patch = (parent, node, oldVNode, newVNode, listener, isSvg) => {
				if (oldVNode === newVNode);
				else if (null != oldVNode && 3 === oldVNode.type && 3 === newVNode.type)
					oldVNode.tag !== newVNode.tag && (node.nodeValue = newVNode.tag)
				else if (null == oldVNode || oldVNode.tag !== newVNode.tag) {
					node = parent.insertBefore(
						createNode((newVNode = maybeVNode(newVNode)), listener, isSvg),
						node,
					)
					null != oldVNode && parent.removeChild(oldVNode.node)
				} else {
					var tmpVKid,
						oldVKid,
						oldKey,
						newKey,
						oldProps = oldVNode.props,
						newProps = newVNode.props,
						oldVKids = oldVNode.children,
						newVKids = newVNode.children,
						oldHead = 0,
						newHead = 0,
						oldTail = oldVKids.length - 1,
						newTail = newVKids.length - 1
					isSvg = isSvg || "svg" === newVNode.tag
					for (var i in { ...oldProps, ...newProps })
						("value" === i || "selected" === i || "checked" === i
							? node[i]
							: oldProps[i]) !== newProps[i] &&
							patchProperty(node, i, oldProps[i], newProps[i], listener, isSvg)
					for (
						;
						newHead <= newTail &&
						oldHead <= oldTail &&
						null != (oldKey = getKey(oldVKids[oldHead])) &&
						oldKey === getKey(newVKids[newHead]);

					)
						hyperapp_patch(
							node,
							oldVKids[oldHead].node,
							oldVKids[oldHead],
							(newVKids[newHead] = maybeVNode(
								newVKids[newHead++],
								oldVKids[oldHead++],
							)),
							listener,
							isSvg,
						)
					for (
						;
						newHead <= newTail &&
						oldHead <= oldTail &&
						null != (oldKey = getKey(oldVKids[oldTail])) &&
						oldKey === getKey(newVKids[newTail]);

					)
						hyperapp_patch(
							node,
							oldVKids[oldTail].node,
							oldVKids[oldTail],
							(newVKids[newTail] = maybeVNode(
								newVKids[newTail--],
								oldVKids[oldTail--],
							)),
							listener,
							isSvg,
						)
					if (oldHead > oldTail)
						for (; newHead <= newTail; )
							node.insertBefore(
								createNode(
									(newVKids[newHead] = maybeVNode(newVKids[newHead++])),
									listener,
									isSvg,
								),
								(oldVKid = oldVKids[oldHead]) && oldVKid.node,
							)
					else if (newHead > newTail)
						for (; oldHead <= oldTail; )
							node.removeChild(oldVKids[oldHead++].node)
					else {
						var keyed = {},
							newKeyed = {}
						for (i = oldHead; i <= oldTail; i++)
							null != (oldKey = oldVKids[i].key) &&
								(keyed[oldKey] = oldVKids[i])
						for (; newHead <= newTail; ) {
							oldKey = getKey((oldVKid = oldVKids[oldHead]))
							newKey = getKey(
								(newVKids[newHead] = maybeVNode(newVKids[newHead], oldVKid)),
							)
							if (
								newKeyed[oldKey] ||
								(null != newKey && newKey === getKey(oldVKids[oldHead + 1]))
							) {
								null == oldKey && node.removeChild(oldVKid.node)
								oldHead++
							} else if (null == newKey || 1 === oldVNode.type) {
								if (null == oldKey) {
									hyperapp_patch(
										node,
										oldVKid && oldVKid.node,
										oldVKid,
										newVKids[newHead],
										listener,
										isSvg,
									)
									newHead++
								}
								oldHead++
							} else {
								if (oldKey === newKey) {
									hyperapp_patch(
										node,
										oldVKid.node,
										oldVKid,
										newVKids[newHead],
										listener,
										isSvg,
									)
									newKeyed[newKey] = !0
									oldHead++
								} else if (null != (tmpVKid = keyed[newKey])) {
									hyperapp_patch(
										node,
										node.insertBefore(tmpVKid.node, oldVKid && oldVKid.node),
										tmpVKid,
										newVKids[newHead],
										listener,
										isSvg,
									)
									newKeyed[newKey] = !0
								} else
									hyperapp_patch(
										node,
										oldVKid && oldVKid.node,
										null,
										newVKids[newHead],
										listener,
										isSvg,
									)
								newHead++
							}
						}
						for (; oldHead <= oldTail; )
							null == getKey((oldVKid = oldVKids[oldHead++])) &&
								node.removeChild(oldVKid.node)
						for (var i in keyed)
							null == newKeyed[i] && node.removeChild(keyed[i].node)
					}
				}
				return (newVNode.node = node)
			},
			maybeVNode = (newVNode, oldVNode) =>
				!0 !== newVNode && !1 !== newVNode && newVNode
					? "function" == typeof newVNode.tag
						? ((!oldVNode ||
								null == oldVNode.memo ||
								((a, b) => {
									for (var k in a) if (a[k] !== b[k]) return !0
									for (var k in b) if (a[k] !== b[k]) return !0
								})(oldVNode.memo, newVNode.memo)) &&
								((oldVNode = newVNode.tag(newVNode.memo)).memo = newVNode.memo),
							oldVNode)
						: newVNode
					: hyperapp_text(""),
			recycleNode = node =>
				3 === node.nodeType
					? hyperapp_text(node.nodeValue, node)
					: createVNode(
							node.nodeName.toLowerCase(),
							EMPTY_OBJ,
							hyperapp_map.call(node.childNodes, recycleNode),
							1,
							node,
						),
			createVNode = (tag, { key, ...props }, children, type, node) => ({
				tag,
				props,
				key,
				children,
				type,
				node,
			}),
			hyperapp_text = (value, node) =>
				createVNode(value, EMPTY_OBJ, EMPTY_ARR, 3, node),
			h = (tag, { class: c, ...props }, children = EMPTY_ARR) =>
				createVNode(
					tag,
					{ ...props, ...(c ? { class: createClass(c) } : EMPTY_OBJ) },
					hyperapp_isArray(children) ? children : [children],
				),
			app = ({
				node,
				view,
				subscriptions,
				dispatch = hyperapp_id,
				init = EMPTY_OBJ,
			}) => {
				var state,
					busy,
					vdom = node && recycleNode(node),
					subs = [],
					update = newState => {
						if (state !== newState) {
							null == (state = newState) &&
								(dispatch = subscriptions = render = hyperapp_id)
							subscriptions &&
								(subs = ((oldSubs, newSubs = EMPTY_ARR, dispatch) => {
									for (
										var oldSub, newSub, subs = [], i = 0;
										i < oldSubs.length || i < newSubs.length;
										i++
									) {
										oldSub = oldSubs[i]
										newSub = newSubs[i]
										subs.push(
											newSub && !0 !== newSub
												? !oldSub ||
													newSub[0] !== oldSub[0] ||
													shouldRestart(newSub[1], oldSub[1])
													? [
															newSub[0],
															newSub[1],
															(oldSub && oldSub[2](),
															newSub[0](dispatch, newSub[1])),
														]
													: oldSub
												: oldSub && oldSub[2](),
										)
									}
									return subs
								})(subs, subscriptions(state), dispatch))
							view && !busy && enqueue(render, (busy = !0))
						}
					},
					render = () =>
						(node = hyperapp_patch(
							node.parentNode,
							node,
							vdom,
							(vdom = view(state)),
							listener,
							(busy = !1),
						)),
					listener = function (event) {
						dispatch(this.events[event.type], event)
					}
				return (
					(dispatch = dispatch((action, props) =>
						"function" == typeof action
							? dispatch(action(state, props))
							: hyperapp_isArray(action)
								? "function" == typeof action[0]
									? dispatch(action[0], action[1])
									: action
											.slice(1)
											.map(
												fx => fx && !0 !== fx && (fx[0] || fx)(dispatch, fx[1]),
												update(action[0]),
											)
								: update(action),
					))(init),
					dispatch
				)
			}
		const wrapApp = (comp, init) =>
			Function_pipe(
				Effect_sync(() => document.createElement(comp.tag)),
				Effect_flatMap(node =>
					Effect_sync(() => ({
						node,
						dispatch: app({ init, view: comp.view, node }),
					})),
				),
			)
		Promise.resolve(!1), Promise.resolve(!0)
		var PROMISE_RESOLVED_VOID = Promise.resolve()
		function util_sleep(time, resolveWith) {
			time || (time = 0)
			return new Promise(function (res) {
				return setTimeout(function () {
					return res(resolveWith)
				}, time)
			})
		}
		function randomToken() {
			return Math.random().toString(36).substring(2)
		}
		var lastMs = 0
		function microSeconds() {
			var ret = 1e3 * Date.now()
			ret <= lastMs && (ret = lastMs + 1)
			lastMs = ret
			return ret
		}
		var NativeMethod = {
			create: function (channelName) {
				var state = {
					time: microSeconds(),
					messagesCallback: null,
					bc: new BroadcastChannel(channelName),
					subFns: [],
				}
				state.bc.onmessage = function (msgEvent) {
					state.messagesCallback && state.messagesCallback(msgEvent.data)
				}
				return state
			},
			close: function (channelState) {
				channelState.bc.close()
				channelState.subFns = []
			},
			onMessage: function (channelState, fn) {
				channelState.messagesCallback = fn
			},
			postMessage: function (channelState, messageJson) {
				try {
					channelState.bc.postMessage(messageJson, !1)
					return PROMISE_RESOLVED_VOID
				} catch (err) {
					return Promise.reject(err)
				}
			},
			canBeUsed: function () {
				if (
					"undefined" != typeof globalThis &&
					globalThis.Deno &&
					globalThis.Deno.args
				)
					return !0
				if (
					("undefined" == typeof window && "undefined" == typeof self) ||
					"function" != typeof BroadcastChannel
				)
					return !1
				if (BroadcastChannel._pubkey)
					throw new Error(
						"BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill",
					)
				return !0
			},
			type: "native",
			averageResponseTime: function () {
				return 150
			},
			microSeconds,
		}
		class ObliviousSet {
			ttl
			map = new Map()
			_to = !1
			constructor(ttl) {
				this.ttl = ttl
			}
			has(value) {
				return this.map.has(value)
			}
			add(value) {
				this.map.set(value, now())
				if (!this._to) {
					this._to = !0
					setTimeout(() => {
						this._to = !1
						!(function (obliviousSet) {
							const olderThen = now() - obliviousSet.ttl,
								iterator = obliviousSet.map[Symbol.iterator]()
							for (;;) {
								const next = iterator.next().value
								if (!next) return
								const value = next[0]
								if (!(next[1] < olderThen)) return
								obliviousSet.map.delete(value)
							}
						})(this)
					}, 0)
				}
			}
			clear() {
				this.map.clear()
			}
		}
		function now() {
			return Date.now()
		}
		function options_fillOptionsWithDefaults() {
			var originalOptions =
					arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
				options = JSON.parse(JSON.stringify(originalOptions))
			void 0 === options.webWorkerSupport && (options.webWorkerSupport = !0)
			options.idb || (options.idb = {})
			options.idb.ttl || (options.idb.ttl = 45e3)
			options.idb.fallbackInterval || (options.idb.fallbackInterval = 150)
			originalOptions.idb &&
				"function" == typeof originalOptions.idb.onclose &&
				(options.idb.onclose = originalOptions.idb.onclose)
			options.localstorage || (options.localstorage = {})
			options.localstorage.removeTimeout ||
				(options.localstorage.removeTimeout = 6e4)
			originalOptions.methods && (options.methods = originalOptions.methods)
			options.node || (options.node = {})
			options.node.ttl || (options.node.ttl = 12e4)
			options.node.maxParallelWrites || (options.node.maxParallelWrites = 2048)
			void 0 === options.node.useFastPath && (options.node.useFastPath = !0)
			return options
		}
		var OBJECT_STORE_ID = "messages",
			TRANSACTION_SETTINGS = { durability: "relaxed" }
		function getIdb() {
			if ("undefined" != typeof indexedDB) return indexedDB
			if ("undefined" != typeof window) {
				if (void 0 !== window.mozIndexedDB) return window.mozIndexedDB
				if (void 0 !== window.webkitIndexedDB) return window.webkitIndexedDB
				if (void 0 !== window.msIndexedDB) return window.msIndexedDB
			}
			return !1
		}
		function commitIndexedDBTransaction(tx) {
			tx.commit && tx.commit()
		}
		function _readLoop(state) {
			state.closed ||
				readNewMessages(state)
					.then(function () {
						return util_sleep(state.options.idb.fallbackInterval)
					})
					.then(function () {
						return _readLoop(state)
					})
		}
		function readNewMessages(state) {
			return state.closed
				? PROMISE_RESOLVED_VOID
				: state.messagesCallback
					? (function (db, lastCursorId) {
							var tx = db.transaction(
									OBJECT_STORE_ID,
									"readonly",
									TRANSACTION_SETTINGS,
								),
								objectStore = tx.objectStore(OBJECT_STORE_ID),
								ret = [],
								keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, 1 / 0)
							if (objectStore.getAll) {
								var getAllRequest = objectStore.getAll(keyRangeValue)
								return new Promise(function (res, rej) {
									getAllRequest.onerror = function (err) {
										return rej(err)
									}
									getAllRequest.onsuccess = function (e) {
										res(e.target.result)
									}
								})
							}
							return new Promise(function (res, rej) {
								var openCursorRequest = (function () {
									try {
										keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, 1 / 0)
										return objectStore.openCursor(keyRangeValue)
									} catch (e) {
										return objectStore.openCursor()
									}
								})()
								openCursorRequest.onerror = function (err) {
									return rej(err)
								}
								openCursorRequest.onsuccess = function (ev) {
									var cursor = ev.target.result
									if (cursor)
										if (cursor.value.id < lastCursorId + 1)
											cursor.continue(lastCursorId + 1)
										else {
											ret.push(cursor.value)
											cursor.continue()
										}
									else {
										commitIndexedDBTransaction(tx)
										res(ret)
									}
								}
							})
						})(state.db, state.lastCursorId).then(function (newerMessages) {
							var useMessages = newerMessages
								.filter(function (msgObj) {
									return !!msgObj
								})
								.map(function (msgObj) {
									msgObj.id > state.lastCursorId &&
										(state.lastCursorId = msgObj.id)
									return msgObj
								})
								.filter(function (msgObj) {
									return (function (msgObj, state) {
										return !(
											msgObj.uuid === state.uuid ||
											state.eMIs.has(msgObj.id) ||
											msgObj.data.time < state.messagesCallbackTime
										)
									})(msgObj, state)
								})
								.sort(function (msgObjA, msgObjB) {
									return msgObjA.time - msgObjB.time
								})
							useMessages.forEach(function (msgObj) {
								if (state.messagesCallback) {
									state.eMIs.add(msgObj.id)
									state.messagesCallback(msgObj.data)
								}
							})
							return PROMISE_RESOLVED_VOID
						})
					: PROMISE_RESOLVED_VOID
		}
		var IndexedDBMethod = {
			create: function (channelName, options) {
				options = options_fillOptionsWithDefaults(options)
				return (function (channelName) {
					var dbName = "pubkey.broadcast-channel-0-" + channelName,
						openRequest = getIdb().open(dbName)
					openRequest.onupgradeneeded = function (ev) {
						ev.target.result.createObjectStore(OBJECT_STORE_ID, {
							keyPath: "id",
							autoIncrement: !0,
						})
					}
					return new Promise(function (res, rej) {
						openRequest.onerror = function (ev) {
							return rej(ev)
						}
						openRequest.onsuccess = function () {
							res(openRequest.result)
						}
					})
				})(channelName).then(function (db) {
					var state = {
						closed: !1,
						lastCursorId: 0,
						channelName,
						options,
						uuid: randomToken(),
						eMIs: new ObliviousSet(2 * options.idb.ttl),
						writeBlockPromise: PROMISE_RESOLVED_VOID,
						messagesCallback: null,
						readQueuePromises: [],
						db,
					}
					db.onclose = function () {
						state.closed = !0
						options.idb.onclose && options.idb.onclose()
					}
					_readLoop(state)
					return state
				})
			},
			close: function (channelState) {
				channelState.closed = !0
				channelState.db.close()
			},
			onMessage: function (channelState, fn, time) {
				channelState.messagesCallbackTime = time
				channelState.messagesCallback = fn
				readNewMessages(channelState)
			},
			postMessage: function (channelState, messageJson) {
				channelState.writeBlockPromise = channelState.writeBlockPromise
					.then(function () {
						return (function (db, readerUuid, messageJson) {
							var writeObject = {
									uuid: readerUuid,
									time: Date.now(),
									data: messageJson,
								},
								tx = db.transaction(
									[OBJECT_STORE_ID],
									"readwrite",
									TRANSACTION_SETTINGS,
								)
							return new Promise(function (res, rej) {
								tx.oncomplete = function () {
									return res()
								}
								tx.onerror = function (ev) {
									return rej(ev)
								}
								tx.objectStore(OBJECT_STORE_ID).add(writeObject)
								commitIndexedDBTransaction(tx)
							})
						})(channelState.db, channelState.uuid, messageJson)
					})
					.then(function () {
						0 === Math.floor(11 * Math.random() + 0) &&
							(function (channelState) {
								return ((db = channelState.db),
								(ttl = channelState.options.idb.ttl),
								(olderThen = Date.now() - ttl),
								(tx = db.transaction(
									OBJECT_STORE_ID,
									"readonly",
									TRANSACTION_SETTINGS,
								)),
								(objectStore = tx.objectStore(OBJECT_STORE_ID)),
								(ret = []),
								new Promise(function (res) {
									objectStore.openCursor().onsuccess = function (ev) {
										var cursor = ev.target.result
										if (cursor) {
											var msgObk = cursor.value
											if (msgObk.time < olderThen) {
												ret.push(msgObk)
												cursor.continue()
											} else {
												commitIndexedDBTransaction(tx)
												res(ret)
											}
										} else res(ret)
									}
								})).then(function (tooOld) {
									return (function (channelState, ids) {
										if (channelState.closed) return Promise.resolve([])
										var objectStore = channelState.db
											.transaction(
												OBJECT_STORE_ID,
												"readwrite",
												TRANSACTION_SETTINGS,
											)
											.objectStore(OBJECT_STORE_ID)
										return Promise.all(
											ids.map(function (id) {
												var deleteRequest = objectStore.delete(id)
												return new Promise(function (res) {
													deleteRequest.onsuccess = function () {
														return res()
													}
												})
											}),
										)
									})(
										channelState,
										tooOld.map(function (msg) {
											return msg.id
										}),
									)
								})
								var db, ttl, olderThen, tx, objectStore, ret
							})(channelState)
					})
				return channelState.writeBlockPromise
			},
			canBeUsed: function () {
				return !!getIdb()
			},
			type: "idb",
			averageResponseTime: function (options) {
				return 2 * options.idb.fallbackInterval
			},
			microSeconds,
		}
		function getLocalStorage() {
			var localStorage
			if ("undefined" == typeof window) return null
			try {
				localStorage = window.localStorage
				localStorage =
					window["ie8-eventlistener/storage"] || window.localStorage
			} catch (e) {}
			return localStorage
		}
		function storageKey(channelName) {
			return "pubkey.broadcastChannel-" + channelName
		}
		function localstorage_canBeUsed() {
			var ls = getLocalStorage()
			if (!ls) return !1
			try {
				var key = "__broadcastchannel_check"
				ls.setItem(key, "works")
				ls.removeItem(key)
			} catch (e) {
				return !1
			}
			return !0
		}
		var LocalstorageMethod = {
				create: function (channelName, options) {
					options = options_fillOptionsWithDefaults(options)
					if (!localstorage_canBeUsed())
						throw new Error("BroadcastChannel: localstorage cannot be used")
					var uuid = randomToken(),
						eMIs = new ObliviousSet(options.localstorage.removeTimeout),
						state = { channelName, uuid, eMIs }
					state.listener = (function (channelName, fn) {
						var key = storageKey(channelName),
							listener = function (ev) {
								ev.key === key &&
									(function (msgObj) {
										if (
											state.messagesCallback &&
											msgObj.uuid !== uuid &&
											msgObj.token &&
											!eMIs.has(msgObj.token) &&
											!(
												msgObj.data.time &&
												msgObj.data.time < state.messagesCallbackTime
											)
										) {
											eMIs.add(msgObj.token)
											state.messagesCallback(msgObj.data)
										}
									})(JSON.parse(ev.newValue))
							}
						window.addEventListener("storage", listener)
						return listener
					})(channelName)
					return state
				},
				close: function (channelState) {
					;(listener = channelState.listener),
						window.removeEventListener("storage", listener)
					var listener
				},
				onMessage: function (channelState, fn, time) {
					channelState.messagesCallbackTime = time
					channelState.messagesCallback = fn
				},
				postMessage: function (channelState, messageJson) {
					return new Promise(function (res) {
						util_sleep().then(function () {
							var key = storageKey(channelState.channelName),
								writeObj = {
									token: randomToken(),
									time: Date.now(),
									data: messageJson,
									uuid: channelState.uuid,
								},
								value = JSON.stringify(writeObj)
							getLocalStorage().setItem(key, value)
							var ev = document.createEvent("Event")
							ev.initEvent("storage", !0, !0)
							ev.key = key
							ev.newValue = value
							window.dispatchEvent(ev)
							res()
						})
					})
				},
				canBeUsed: localstorage_canBeUsed,
				type: "localstorage",
				averageResponseTime: function () {
					var userAgent = navigator.userAgent.toLowerCase()
					return userAgent.includes("safari") && !userAgent.includes("chrome")
						? 240
						: 120
				},
				microSeconds,
			},
			simulate_microSeconds = microSeconds,
			SIMULATE_CHANNELS = new Set(),
			SimulateMethod = {
				create: function (channelName) {
					var state = {
						time: simulate_microSeconds(),
						name: channelName,
						messagesCallback: null,
					}
					SIMULATE_CHANNELS.add(state)
					return state
				},
				close: function (channelState) {
					SIMULATE_CHANNELS.delete(channelState)
				},
				onMessage: function (channelState, fn) {
					channelState.messagesCallback = fn
				},
				postMessage: function (channelState, messageJson) {
					return new Promise(function (res) {
						return setTimeout(function () {
							Array.from(SIMULATE_CHANNELS).forEach(function (channel) {
								channel.name === channelState.name &&
									channel !== channelState &&
									channel.messagesCallback &&
									channel.time < messageJson.time &&
									channel.messagesCallback(messageJson)
							})
							res()
						}, 5)
					})
				},
				canBeUsed: function () {
					return !0
				},
				type: "simulate",
				averageResponseTime: function () {
					return 5
				},
				microSeconds: simulate_microSeconds,
			},
			METHODS = [NativeMethod, IndexedDBMethod, LocalstorageMethod],
			OPEN_BROADCAST_CHANNELS = new Set(),
			lastId = 0,
			broadcast_channel_BroadcastChannel = function (name, options) {
				this.id = lastId++
				OPEN_BROADCAST_CHANNELS.add(this)
				this.name = name
				this.options = options_fillOptionsWithDefaults(options)
				this.method = (function (options) {
					var chooseMethods = []
						.concat(options.methods, METHODS)
						.filter(Boolean)
					if (options.type) {
						if ("simulate" === options.type) return SimulateMethod
						var ret = chooseMethods.find(function (m) {
							return m.type === options.type
						})
						if (ret) return ret
						throw new Error("method-type " + options.type + " not found")
					}
					options.webWorkerSupport ||
						(chooseMethods = chooseMethods.filter(function (m) {
							return "idb" !== m.type
						}))
					var useMethod = chooseMethods.find(function (method) {
						return method.canBeUsed()
					})
					if (useMethod) return useMethod
					throw new Error(
						"No usable method found in " +
							JSON.stringify(
								METHODS.map(function (m) {
									return m.type
								}),
							),
					)
				})(this.options)
				this._iL = !1
				this._onML = null
				this._addEL = { message: [], internal: [] }
				this._uMP = new Set()
				this._befC = []
				this._prepP = null
				!(function (channel) {
					var obj,
						maybePromise = channel.method.create(channel.name, channel.options)
					if ((obj = maybePromise) && "function" == typeof obj.then) {
						channel._prepP = maybePromise
						maybePromise.then(function (s) {
							channel._state = s
						})
					} else channel._state = maybePromise
				})(this)
			}
		broadcast_channel_BroadcastChannel._pubkey = !0
		broadcast_channel_BroadcastChannel.prototype = {
			postMessage: function (msg) {
				if (this.closed)
					throw new Error(
						"BroadcastChannel.postMessage(): Cannot post message after channel has closed " +
							JSON.stringify(msg),
					)
				return _post(this, "message", msg)
			},
			postInternal: function (msg) {
				return _post(this, "internal", msg)
			},
			set onmessage(fn) {
				var listenObj = { time: this.method.microSeconds(), fn }
				_removeListenerObject(this, "message", this._onML)
				if (fn && "function" == typeof fn) {
					this._onML = listenObj
					_addListenerObject(this, "message", listenObj)
				} else this._onML = null
			},
			addEventListener: function (type, fn) {
				_addListenerObject(this, type, { time: this.method.microSeconds(), fn })
			},
			removeEventListener: function (type, fn) {
				_removeListenerObject(
					this,
					type,
					this._addEL[type].find(function (obj) {
						return obj.fn === fn
					}),
				)
			},
			close: function () {
				var _this = this
				if (!this.closed) {
					OPEN_BROADCAST_CHANNELS.delete(this)
					this.closed = !0
					var awaitPrepare = this._prepP ? this._prepP : PROMISE_RESOLVED_VOID
					this._onML = null
					this._addEL.message = []
					return awaitPrepare
						.then(function () {
							return Promise.all(Array.from(_this._uMP))
						})
						.then(function () {
							return Promise.all(
								_this._befC.map(function (fn) {
									return fn()
								}),
							)
						})
						.then(function () {
							return _this.method.close(_this._state)
						})
				}
			},
			get type() {
				return this.method.type
			},
			get isClosed() {
				return this.closed
			},
		}
		function _post(broadcastChannel, type, msg) {
			var msgObj = {
				time: broadcastChannel.method.microSeconds(),
				type,
				data: msg,
			}
			return (
				broadcastChannel._prepP
					? broadcastChannel._prepP
					: PROMISE_RESOLVED_VOID
			).then(function () {
				var sendPromise = broadcastChannel.method.postMessage(
					broadcastChannel._state,
					msgObj,
				)
				broadcastChannel._uMP.add(sendPromise)
				sendPromise.catch().then(function () {
					return broadcastChannel._uMP.delete(sendPromise)
				})
				return sendPromise
			})
		}
		function _hasMessageListeners(channel) {
			return (
				channel._addEL.message.length > 0 || channel._addEL.internal.length > 0
			)
		}
		function _addListenerObject(channel, type, obj) {
			channel._addEL[type].push(obj)
			!(function (channel) {
				if (!channel._iL && _hasMessageListeners(channel)) {
					var listenerFn = function (msgObj) {
							channel._addEL[msgObj.type].forEach(function (listenerObject) {
								msgObj.time >= listenerObject.time &&
									listenerObject.fn(msgObj.data)
							})
						},
						time = channel.method.microSeconds()
					if (channel._prepP)
						channel._prepP.then(function () {
							channel._iL = !0
							channel.method.onMessage(channel._state, listenerFn, time)
						})
					else {
						channel._iL = !0
						channel.method.onMessage(channel._state, listenerFn, time)
					}
				}
			})(channel)
		}
		function _removeListenerObject(channel, type, obj) {
			channel._addEL[type] = channel._addEL[type].filter(function (o) {
				return o !== obj
			})
			!(function (channel) {
				if (channel._iL && !_hasMessageListeners(channel)) {
					channel._iL = !1
					var time = channel.method.microSeconds()
					channel.method.onMessage(channel._state, null, time)
				}
			})(channel)
		}
		const SynchronizedRef_make = makeSynchronized,
			SynchronizedRef_get = ref_get,
			SynchronizedRef_set = ref_set,
			SynchronizedRef_update = ref_update,
			Schedule_fixed = intervalInput => {
				const interval = decode(intervalInput),
					intervalMillis = toMillis(interval)
				return (
					(initial = [Option_none(), 0]),
					new ScheduleImpl(initial, (now, _, [option, n]) =>
						sync(() => {
							switch (option._tag) {
								case "None":
									return [
										[Option_some([now, now + intervalMillis]), n + 1],
										n,
										ScheduleDecision_continueWith(
											ScheduleInterval_after(now + intervalMillis),
										),
									]
								case "Some": {
									const [startMillis, lastRun] = option.value,
										runningBehind = now > lastRun + intervalMillis,
										boundary = equals(interval, zero)
											? interval
											: Duration_millis(
													intervalMillis -
														((now - startMillis) % intervalMillis),
												),
										sleepTime = equals(boundary, zero) ? interval : boundary,
										nextRun = runningBehind ? now : now + toMillis(sleepTime)
									return [
										[Option_some([startMillis, nextRun]), n + 1],
										n,
										ScheduleDecision_continueWith(
											ScheduleInterval_after(nextRun),
										),
									]
								}
							}
						}),
					)
				)
				var initial
			}
		var fast_deep_equal = __webpack_require__(371),
			fast_deep_equal_default = __webpack_require__.n(fast_deep_equal)
		const makeSubject = configKeys =>
				Function_pipe(
					configKeys,
					Array_map(x => [x, new external_rxjs_namespaceObject.Subject()]),
					Object.fromEntries,
				),
			mapObject = f => o =>
				Function_pipe(Object.entries(o), Array_map(f), Object.fromEntries),
			makeGetter = c =>
				Function_pipe(
					c,
					mapObject(([x]) => [x, Effect_sync(() => c[x])]),
				),
			external_DeepDiff_namespaceObject = DeepDiff,
			makePageState = mapObject(([k, v]) => [
				k,
				{ ele: Option_none(), read: v },
			]),
			external_astring_namespaceObject = astring,
			external_jsep_namespaceObject = jsep
		var external_jsep_default = __webpack_require__.n(
				external_jsep_namespaceObject,
			),
			u = {
				"||": function (r, e) {
					return r || e
				},
				"&&": function (r, e) {
					return r && e
				},
				"|": function (r, e) {
					return r | e
				},
				"^": function (r, e) {
					return r ^ e
				},
				"&": function (r, e) {
					return r & e
				},
				"==": function (r, e) {
					return r == e
				},
				"!=": function (r, e) {
					return r != e
				},
				"===": function (r, e) {
					return r === e
				},
				"!==": function (r, e) {
					return r !== e
				},
				"<": function (r, e) {
					return r < e
				},
				">": function (r, e) {
					return r > e
				},
				"<=": function (r, e) {
					return r <= e
				},
				">=": function (r, e) {
					return r >= e
				},
				"<<": function (r, e) {
					return r << e
				},
				">>": function (r, e) {
					return r >> e
				},
				">>>": function (r, e) {
					return r >>> e
				},
				"+": function (r, e) {
					return r + e
				},
				"-": function (r, e) {
					return r - e
				},
				"*": function (r, e) {
					return r * e
				},
				"/": function (r, e) {
					return r / e
				},
				"%": function (r, e) {
					return r % e
				},
			},
			i = {
				"-": function (r) {
					return -r
				},
				"+": function (r) {
					return +r
				},
				"~": function (r) {
					return ~r
				},
				"!": function (r) {
					return !r
				},
			}
		function s(r, e) {
			return r.map(function (r) {
				return a(r, e)
			})
		}
		function c(r, e) {
			var n,
				t = a(r.object, e)
			if (
				((n = r.computed ? a(r.property, e) : r.property.name),
				/^__proto__|prototype|constructor$/.test(n))
			)
				throw Error('Access to member "' + n + '" disallowed.')
			return [t, t[n]]
		}
		function a(r, e) {
			var n = r
			switch (n.type) {
				case "ArrayExpression":
					return s(n.elements, e)
				case "BinaryExpression":
					return u[n.operator](a(n.left, e), a(n.right, e))
				case "CallExpression":
					var t, o, l
					if (
						("MemberExpression" === n.callee.type
							? ((t = (l = c(n.callee, e))[0]), (o = l[1]))
							: (o = a(n.callee, e)),
						"function" != typeof o)
					)
						return
					return o.apply(t, s(n.arguments, e))
				case "ConditionalExpression":
					return a(n.test, e) ? a(n.consequent, e) : a(n.alternate, e)
				case "Identifier":
					return e[n.name]
				case "Literal":
					return n.value
				case "LogicalExpression":
					return "||" === n.operator
						? a(n.left, e) || a(n.right, e)
						: "&&" === n.operator
							? a(n.left, e) && a(n.right, e)
							: u[n.operator](a(n.left, e), a(n.right, e))
				case "MemberExpression":
					return c(n, e)[1]
				case "ThisExpression":
					return e
				case "UnaryExpression":
					return i[n.operator](a(n.argument, e))
				default:
					return
			}
		}
		const fycKey = key => `FYC_${key}`,
			languages = ["FYC_EN", "FYC_JA", "FYC_ZH_CN"],
			stringsArgs = [
				[],
				x =>
					Function_pipe(
						String_split(x, /\r\n|\n/),
						Array_filter(not(String_isEmpty)),
					),
				join("\n"),
			],
			sc = (k, d) => {
				return (
					(key = fycKey(k)),
					(defaultValue = d),
					{
						gmKey: key,
						getValue: Effect_promise(async () =>
							GM.getValue(key, defaultValue),
						),
						defaultValue,
						toGm: Function_identity,
					}
				)
				var key, defaultValue
			},
			ic = (k, d, c, g) => {
				return (
					(key = fycKey(k)),
					(toConfig = c),
					Function_pipe(
						{ gmKey: key, defaultValue: (defaultValue = d), toGm: g },
						ctx => ({
							...ctx,
							getValue: Function_pipe(
								Effect_promise(() => GM.getValue(key)),
								Effect_map(x => (void 0 !== x ? toConfig(x) : defaultValue)),
							),
						}),
					)
				)
				var key, defaultValue, toConfig
			},
			src_defaultGMConfig = Function_pipe(
				{
					lang: ic(
						"LANG",
						"FYC_EN",
						x => (languages.includes(x) ? x : "FYC_EN"),
						x => x,
					),
					font: sc("FONT", "MS PGothic"),
					chatOpacity: sc("OPACITY", 0.8),
					color: sc("COLOR", "#ffffff"),
					ownerColor: sc("COLOR_OWNER", "#ffd600"),
					moderatorColor: sc("COLOR_MODERATOR", "#c564ff"),
					memberColor: sc("COLOR_MEMBER", "#9fffff"),
					fontSize: sc("SIZE", 1),
					fontWeight: sc("WEIGHT", 730),
					shadowFontWeight: sc("WEIGHT_SHADOW", 1),
					maxChatCount: sc("LIMIT", 40),
					flowSpeed: sc("SPEED", 18),
					maxChatLength: sc("MAX", 100),
					laneCount: sc("LANE_DIV", 12),
					bannedWords: ic("NG_WORDS", ...stringsArgs),
					bannedWordRegexes: ic("NG_REG_WORDS", ...stringsArgs),
					bannedUsers: ic("NG_USERS", ...stringsArgs),
					createChats: sc("TOGGLE_CREATE_COMMENTS", !0),
					noOverlap: sc("NO_OVERLAP", !0),
					createBanButton: sc("NG_BUTTON", !0),
					simplifyChatField: sc("SIMPLE_CHAT_FIELD", !1),
					displayModName: sc("DISPLAY_MODERATOR_NAME", !0),
					displaySuperChatAuthor: sc("DISPLAY_SUPER_CHAT_AUTHOR", !0),
					textOnly: sc("TEXT_ONLY", !1),
					timingFunction: sc("TIMING_FUNCTION", "linear"),
					displayChats: sc("DISPLAY_COMMENTS", !0),
					minSpacing: sc("MIN_SPACING", 0.5),
					fieldScale: sc("FIELD_SCALE", 1),
					flowY1: sc("flowY1", 0),
					flowY2: sc("flowY2", 1),
					flowX1: sc("flowX1", 0),
					flowX2: sc("flowX2", 1),
					shadowColor: sc("shadowColor", "#000000"),
					logEvents: sc("logEvents", !0),
				},
				x => ({
					...x,
					filterExp: ic(
						"filterExp",
						external_jsep_default()(
							`\n  or([\n  A.some(\n    flip(flow([inText, A.some]))(${JSON.stringify(x.bannedWords.defaultValue)})\n  )(A.getSomes([\n    messageText,\n    paymentInfo\n  ])),\n  A.some(\n    flip(flow([matchedByText, A.some]))(${JSON.stringify(x.bannedWordRegexes.defaultValue)})\n  )(A.getSomes([\n    messageText,\n    paymentInfo\n  ])),\n  O.exists(\n    flip(flow([eqText, A.some]))(${JSON.stringify(x.bannedUsers.defaultValue)})\n  )(authorID)\n  ])\n        `,
						),
						external_jsep_default(),
						external_astring_namespaceObject.generate,
					),
				}),
			),
			configKeys = Object.keys(src_defaultGMConfig),
			removeOldChats = flowChats => maxChatCount =>
				Function_pipe(
					SynchronizedRef_get(flowChats),
					Effect_map(
						sort(
							Order_mapInput(x => Either_isRight(x.animationState))(
								Boolean_Order,
							),
						),
					),
					Effect_map(x => splitAt(x, x.length - maxChatCount)),
					Effect_flatMap(([oldChats, newChats]) =>
						Function_pipe(
							oldChats,
							Effect_forEach(x =>
								Function_pipe(
									Effect_logDebug("RemoveChat"),
									Effect_zipRight(
										Effect_sync(() => {
											x.element.remove()
										}),
									),
								),
							),
							Effect_map(() => newChats),
						),
					),
					Effect_tap(x => Effect_logDebug(`length after clear: ${x.length}`)),
					Effect_flatMap(x => SynchronizedRef_set(flowChats, x)),
				),
			lit_html_t = globalThis,
			lit_html_i = lit_html_t.trustedTypes,
			lit_html_s = lit_html_i
				? lit_html_i.createPolicy("lit-html", { createHTML: t => t })
				: void 0,
			lit_html_h = `lit$${Math.random().toFixed(9).slice(2)}$`,
			lit_html_o = "?" + lit_html_h,
			lit_html_n = `<${lit_html_o}>`,
			lit_html_r = document,
			lit_html_l = () => lit_html_r.createComment(""),
			lit_html_c = t =>
				null === t || ("object" != typeof t && "function" != typeof t),
			lit_html_a = Array.isArray,
			d = "[ \t\n\f\r]",
			lit_html_f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g,
			v = /-->/g,
			_ = />/g,
			lit_html_m = RegExp(
				`>|${d}(?:([^\\s"'>=/]+)(${d}*=${d}*(?:[^ \t\n\f\r"'\`<>=]|("|')|))|$)`,
				"g",
			),
			lit_html_p = /'/g,
			g = /"/g,
			$ = /^(?:script|style|textarea|title)$/i,
			y =
				t =>
				(i, ...s) => ({ _$litType$: t, strings: i, values: s }),
			lit_html_x = y(1),
			w = (y(2), Symbol.for("lit-noChange")),
			T = Symbol.for("lit-nothing"),
			A = new WeakMap(),
			lit_html_E = lit_html_r.createTreeWalker(lit_html_r, 129)
		function C(t, i) {
			if (!Array.isArray(t) || !t.hasOwnProperty("raw"))
				throw Error("invalid template strings array")
			return void 0 !== lit_html_s ? lit_html_s.createHTML(i) : i
		}
		const P = (t, i) => {
			const s = t.length - 1,
				o = []
			let r,
				l = 2 === i ? "<svg>" : "",
				c = lit_html_f
			for (let i = 0; i < s; i++) {
				const s = t[i]
				let a,
					u,
					d = -1,
					y = 0
				for (
					;
					y < s.length && ((c.lastIndex = y), (u = c.exec(s)), null !== u);

				)
					(y = c.lastIndex),
						c === lit_html_f
							? "!--" === u[1]
								? (c = v)
								: void 0 !== u[1]
									? (c = _)
									: void 0 !== u[2]
										? ($.test(u[2]) && (r = RegExp("</" + u[2], "g")),
											(c = lit_html_m))
										: void 0 !== u[3] && (c = lit_html_m)
							: c === lit_html_m
								? ">" === u[0]
									? ((c = r ?? lit_html_f), (d = -1))
									: void 0 === u[1]
										? (d = -2)
										: ((d = c.lastIndex - u[2].length),
											(a = u[1]),
											(c =
												void 0 === u[3]
													? lit_html_m
													: '"' === u[3]
														? g
														: lit_html_p))
								: c === g || c === lit_html_p
									? (c = lit_html_m)
									: c === v || c === _
										? (c = lit_html_f)
										: ((c = lit_html_m), (r = void 0))
				const x = c === lit_html_m && t[i + 1].startsWith("/>") ? " " : ""
				l +=
					c === lit_html_f
						? s + lit_html_n
						: d >= 0
							? (o.push(a),
								s.slice(0, d) + "$lit$" + s.slice(d) + lit_html_h + x)
							: s + lit_html_h + (-2 === d ? i : x)
			}
			return [C(t, l + (t[s] || "<?>") + (2 === i ? "</svg>" : "")), o]
		}
		class V {
			constructor({ strings: t, _$litType$: s }, n) {
				let r
				this.parts = []
				let c = 0,
					a = 0
				const u = t.length - 1,
					d = this.parts,
					[f, v] = P(t, s)
				if (
					((this.el = V.createElement(f, n)),
					(lit_html_E.currentNode = this.el.content),
					2 === s)
				) {
					const t = this.el.content.firstChild
					t.replaceWith(...t.childNodes)
				}
				for (; null !== (r = lit_html_E.nextNode()) && d.length < u; ) {
					if (1 === r.nodeType) {
						if (r.hasAttributes())
							for (const t of r.getAttributeNames())
								if (t.endsWith("$lit$")) {
									const i = v[a++],
										s = r.getAttribute(t).split(lit_html_h),
										e = /([.?@])?(.*)/.exec(i)
									d.push({
										type: 1,
										index: c,
										name: e[2],
										strings: s,
										ctor:
											"." === e[1]
												? k
												: "?" === e[1]
													? H
													: "@" === e[1]
														? I
														: R,
									}),
										r.removeAttribute(t)
								} else
									t.startsWith(lit_html_h) &&
										(d.push({ type: 6, index: c }), r.removeAttribute(t))
						if ($.test(r.tagName)) {
							const t = r.textContent.split(lit_html_h),
								s = t.length - 1
							if (s > 0) {
								r.textContent = lit_html_i ? lit_html_i.emptyScript : ""
								for (let i = 0; i < s; i++)
									r.append(t[i], lit_html_l()),
										lit_html_E.nextNode(),
										d.push({ type: 2, index: ++c })
								r.append(t[s], lit_html_l())
							}
						}
					} else if (8 === r.nodeType)
						if (r.data === lit_html_o) d.push({ type: 2, index: c })
						else {
							let t = -1
							for (; -1 !== (t = r.data.indexOf(lit_html_h, t + 1)); )
								d.push({ type: 7, index: c }), (t += lit_html_h.length - 1)
						}
					c++
				}
			}
			static createElement(t, i) {
				const s = lit_html_r.createElement("template")
				return (s.innerHTML = t), s
			}
		}
		function N(t, i, s = t, e) {
			if (i === w) return i
			let h = void 0 !== e ? s._$Co?.[e] : s._$Cl
			const o = lit_html_c(i) ? void 0 : i._$litDirective$
			return (
				h?.constructor !== o &&
					(h?._$AO?.(!1),
					void 0 === o ? (h = void 0) : ((h = new o(t)), h._$AT(t, s, e)),
					void 0 !== e ? ((s._$Co ??= [])[e] = h) : (s._$Cl = h)),
				void 0 !== h && (i = N(t, h._$AS(t, i.values), h, e)),
				i
			)
		}
		class S {
			constructor(t, i) {
				;(this._$AV = []),
					(this._$AN = void 0),
					(this._$AD = t),
					(this._$AM = i)
			}
			get parentNode() {
				return this._$AM.parentNode
			}
			get _$AU() {
				return this._$AM._$AU
			}
			u(t) {
				const {
						el: { content: i },
						parts: s,
					} = this._$AD,
					e = (t?.creationScope ?? lit_html_r).importNode(i, !0)
				lit_html_E.currentNode = e
				let h = lit_html_E.nextNode(),
					o = 0,
					n = 0,
					l = s[0]
				for (; void 0 !== l; ) {
					if (o === l.index) {
						let i
						2 === l.type
							? (i = new M(h, h.nextSibling, this, t))
							: 1 === l.type
								? (i = new l.ctor(h, l.name, l.strings, this, t))
								: 6 === l.type && (i = new L(h, this, t)),
							this._$AV.push(i),
							(l = s[++n])
					}
					o !== l?.index && ((h = lit_html_E.nextNode()), o++)
				}
				return (lit_html_E.currentNode = lit_html_r), e
			}
			p(t) {
				let i = 0
				for (const s of this._$AV)
					void 0 !== s &&
						(void 0 !== s.strings
							? (s._$AI(t, s, i), (i += s.strings.length - 2))
							: s._$AI(t[i])),
						i++
			}
		}
		class M {
			get _$AU() {
				return this._$AM?._$AU ?? this._$Cv
			}
			constructor(t, i, s, e) {
				;(this.type = 2),
					(this._$AH = T),
					(this._$AN = void 0),
					(this._$AA = t),
					(this._$AB = i),
					(this._$AM = s),
					(this.options = e),
					(this._$Cv = e?.isConnected ?? !0)
			}
			get parentNode() {
				let t = this._$AA.parentNode
				const i = this._$AM
				return void 0 !== i && 11 === t?.nodeType && (t = i.parentNode), t
			}
			get startNode() {
				return this._$AA
			}
			get endNode() {
				return this._$AB
			}
			_$AI(t, i = this) {
				;(t = N(this, t, i)),
					lit_html_c(t)
						? t === T || null == t || "" === t
							? (this._$AH !== T && this._$AR(), (this._$AH = T))
							: t !== this._$AH && t !== w && this._(t)
						: void 0 !== t._$litType$
							? this.$(t)
							: void 0 !== t.nodeType
								? this.T(t)
								: (t =>
											lit_html_a(t) ||
											"function" == typeof t?.[Symbol.iterator])(t)
									? this.k(t)
									: this._(t)
			}
			S(t) {
				return this._$AA.parentNode.insertBefore(t, this._$AB)
			}
			T(t) {
				this._$AH !== t && (this._$AR(), (this._$AH = this.S(t)))
			}
			_(t) {
				this._$AH !== T && lit_html_c(this._$AH)
					? (this._$AA.nextSibling.data = t)
					: this.T(lit_html_r.createTextNode(t)),
					(this._$AH = t)
			}
			$(t) {
				const { values: i, _$litType$: s } = t,
					e =
						"number" == typeof s
							? this._$AC(t)
							: (void 0 === s.el &&
									(s.el = V.createElement(C(s.h, s.h[0]), this.options)),
								s)
				if (this._$AH?._$AD === e) this._$AH.p(i)
				else {
					const t = new S(e, this),
						s = t.u(this.options)
					t.p(i), this.T(s), (this._$AH = t)
				}
			}
			_$AC(t) {
				let i = A.get(t.strings)
				return void 0 === i && A.set(t.strings, (i = new V(t))), i
			}
			k(t) {
				lit_html_a(this._$AH) || ((this._$AH = []), this._$AR())
				const i = this._$AH
				let s,
					e = 0
				for (const h of t)
					e === i.length
						? i.push(
								(s = new M(
									this.S(lit_html_l()),
									this.S(lit_html_l()),
									this,
									this.options,
								)),
							)
						: (s = i[e]),
						s._$AI(h),
						e++
				e < i.length && (this._$AR(s && s._$AB.nextSibling, e), (i.length = e))
			}
			_$AR(t = this._$AA.nextSibling, i) {
				for (this._$AP?.(!1, !0, i); t && t !== this._$AB; ) {
					const i = t.nextSibling
					t.remove(), (t = i)
				}
			}
			setConnected(t) {
				void 0 === this._$AM && ((this._$Cv = t), this._$AP?.(t))
			}
		}
		class R {
			get tagName() {
				return this.element.tagName
			}
			get _$AU() {
				return this._$AM._$AU
			}
			constructor(t, i, s, e, h) {
				;(this.type = 1),
					(this._$AH = T),
					(this._$AN = void 0),
					(this.element = t),
					(this.name = i),
					(this._$AM = e),
					(this.options = h),
					s.length > 2 || "" !== s[0] || "" !== s[1]
						? ((this._$AH = Array(s.length - 1).fill(new String())),
							(this.strings = s))
						: (this._$AH = T)
			}
			_$AI(t, i = this, s, e) {
				const h = this.strings
				let o = !1
				if (void 0 === h)
					(t = N(this, t, i, 0)),
						(o = !lit_html_c(t) || (t !== this._$AH && t !== w)),
						o && (this._$AH = t)
				else {
					const e = t
					let n, r
					for (t = h[0], n = 0; n < h.length - 1; n++)
						(r = N(this, e[s + n], i, n)),
							r === w && (r = this._$AH[n]),
							(o ||= !lit_html_c(r) || r !== this._$AH[n]),
							r === T ? (t = T) : t !== T && (t += (r ?? "") + h[n + 1]),
							(this._$AH[n] = r)
				}
				o && !e && this.j(t)
			}
			j(t) {
				t === T
					? this.element.removeAttribute(this.name)
					: this.element.setAttribute(this.name, t ?? "")
			}
		}
		class k extends R {
			constructor() {
				super(...arguments), (this.type = 3)
			}
			j(t) {
				this.element[this.name] = t === T ? void 0 : t
			}
		}
		class H extends R {
			constructor() {
				super(...arguments), (this.type = 4)
			}
			j(t) {
				this.element.toggleAttribute(this.name, !!t && t !== T)
			}
		}
		class I extends R {
			constructor(t, i, s, e, h) {
				super(t, i, s, e, h), (this.type = 5)
			}
			_$AI(t, i = this) {
				if ((t = N(this, t, i, 0) ?? T) === w) return
				const s = this._$AH,
					e =
						(t === T && s !== T) ||
						t.capture !== s.capture ||
						t.once !== s.once ||
						t.passive !== s.passive,
					h = t !== T && (s === T || e)
				e && this.element.removeEventListener(this.name, this, s),
					h && this.element.addEventListener(this.name, this, t),
					(this._$AH = t)
			}
			handleEvent(t) {
				"function" == typeof this._$AH
					? this._$AH.call(this.options?.host ?? this.element, t)
					: this._$AH.handleEvent(t)
			}
		}
		class L {
			constructor(t, i, s) {
				;(this.element = t),
					(this.type = 6),
					(this._$AN = void 0),
					(this._$AM = i),
					(this.options = s)
			}
			get _$AU() {
				return this._$AM._$AU
			}
			_$AI(t) {
				N(this, t)
			}
		}
		const Z = lit_html_t.litHtmlPolyfillSupport
		Z?.(V, M), (lit_html_t.litHtmlVersions ??= []).push("3.1.4")
		class directive_i {
			constructor(t) {}
			get _$AU() {
				return this._$AM._$AU
			}
			_$AT(t, e, i) {
				;(this._$Ct = t), (this._$AM = e), (this._$Ci = i)
			}
			_$AS(t, e) {
				return this.update(t, e)
			}
			update(t, e) {
				return this.render(...e)
			}
		}
		const style_map_o =
				((t = class extends directive_i {
					constructor(t) {
						if (
							(super(t),
							1 !== t.type || "style" !== t.name || t.strings?.length > 2)
						)
							throw Error(
								"The `styleMap` directive must be used in the `style` attribute and must be the only part in the attribute.",
							)
					}
					render(t) {
						return Object.keys(t).reduce((e, r) => {
							const s = t[r]
							return null == s
								? e
								: e +
										`${(r = r.includes("-") ? r : r.replace(/(?:^(webkit|moz|ms|o)|)(?=[A-Z])/g, "-$&").toLowerCase())}:${s};`
						}, "")
					}
					update(e, [r]) {
						const { style: s } = e.element
						if (void 0 === this.ft)
							return (this.ft = new Set(Object.keys(r))), this.render(r)
						for (const t of this.ft)
							null == r[t] &&
								(this.ft.delete(t),
								t.includes("-") ? s.removeProperty(t) : (s[t] = null))
						for (const t in r) {
							const e = r[t]
							if (null != e) {
								this.ft.add(t)
								const r = "string" == typeof e && e.endsWith(" !important")
								t.includes("-") || r
									? s.setProperty(
											t,
											r ? e.slice(0, -11) : e,
											r ? "important" : "",
										)
									: (s[t] = e)
							}
						}
						return w
					}
				}),
				(...e) => ({ _$litDirective$: t, values: e })),
			getChatFontSize = ({ config: { value: config }, playerRect }) =>
				SynchronizedRef_get(playerRect).pipe(
					Effect_map(
						rect =>
							Math.round(
								((Math.max(config.fontSize - 0.2, 0.01) * rect.height) /
									config.laneCount) *
									(config.flowY2 - config.flowY1) *
									100,
							) / 100,
					),
				),
			textShadow = shadowColor => offset =>
				Function_pipe(
					offset,
					x => `${x}px`,
					x => (a, b) => `${a}${x} ${b}${x} ${shadowColor}99`,
					x => join(", ")([x("-", "-"), x("", "-"), x("-", ""), x("", "")]),
				),
			textStyle = { fontFamily: "inherit" },
			renderChat = chat => mainState =>
				((chat, mainState) =>
					Function_pipe(
						Effect_gen(function* () {
							return {
								data: chat.data,
								config: mainState.config.value,
								fontSize: yield* getChatFontSize(mainState),
							}
						}),
						Effect_map(
							({ data, config, fontSize }) =>
								lit_html_x`<span style=${style_map_o({ fontSize: `${fontSize}px`, visibility: config.displayChats ? "visible" : "hidden", color: "owner" === data.authorType ? config.ownerColor : "moderator" === data.authorType ? config.moderatorColor : "member" === data.authorType ? config.memberColor : config.color, fontWeight: config.fontWeight.toString(), fontFamily: config.font, opacity: config.chatOpacity.toString(), textShadow: textShadow(config.shadowColor)(config.shadowFontWeight) })}>${Function_pipe(
									[
										Function_pipe(
											data.authorName,
											filter(
												() =>
													("moderator" === data.authorType &&
														config.displayModName) ||
													(Option_isSome(data.paymentInfo) &&
														config.displaySuperChatAuthor),
											),
											map(
												text =>
													lit_html_x`<span style=${style_map_o({ ...match(data.textColor, { onNone: () => {}, onSome: x => ({ color: x }) }), fontSize: "0.84em", ...textStyle })}>${text}: </span>`,
											),
										),
										Function_pipe(
											data.messageElement,
											map(x =>
												((message, config) => {
													const eleWin =
															message.ownerDocument.defaultView ?? window,
														{ maxChatLength } = config
													return Function_pipe(
														Array.from(message.childNodes),
														Array_reduce(
															{ vnodes: [], length: 0 },
															({ vnodes, length }, node) => {
																return length >= maxChatLength
																	? { vnodes, length }
																	: !config.textOnly &&
																		  node instanceof eleWin.HTMLImageElement
																		? {
																				vnodes: [
																					...vnodes,
																					lit_html_x`<img style=${style_map_o({ height: "1em", width: "1em", verticalAlign: "text-top" })} src=${node.src.replace(/=w\d+-h\d+-c-k-nd$/, "")} alt=${node.alt}>`,
																				],
																				length: length + 1,
																			}
																		: Function_pipe(
																				node.textContent ?? "",
																				((end = maxChatLength),
																				self => self.slice(0, end)),
																				x =>
																					node instanceof
																					eleWin.HTMLAnchorElement
																						? {
																								vnodes: [
																									...vnodes,
																									lit_html_x`<span style=${style_map_o({ fontSize: "0.84em", textDecoration: "underline", ...textStyle })}>${x}</span>`,
																								],
																								length: length + x.length,
																							}
																						: {
																								vnodes: [
																									...vnodes,
																									lit_html_x`${x}`,
																								],
																								length: length + x.length,
																							},
																			)
																var end
															},
														),
													)
												})(x, config),
											),
											map(
												text =>
													lit_html_x`<span style=${style_map_o({ ...match(data.textColor, { onNone: () => {}, onSome: x => ({ color: x }) }), ...textStyle })}>${text.vnodes}</span>`,
											),
										),
										Function_pipe(
											data.paymentInfo,
											map(
												text =>
													lit_html_x`<span style=${style_map_o({ ...match(data.paidColor, { onNone: () => {}, onSome: x => ({ color: x }) }), fontSize: "0.84em", ...textStyle })}><strong style=${style_map_o(textStyle)}></strong> ${text.trim()}</span>`,
											),
										),
									],
									Array_getSomes,
								)}</span>`,
						),
					))(chat, mainState).pipe(
					Effect_flatMap(node =>
						Effect_sync(() =>
							((t, i, s) => {
								const e = i
								let h = e._$litPart$
								if (void 0 === h) {
									const t = null
									e._$litPart$ = h = new M(
										i.insertBefore(lit_html_l(), t),
										t,
										void 0,
										{},
									)
								}
								return h._$AI(t), h
							})(node, chat.element),
						),
					),
				),
			external_window_hash_it_namespaceObject = window["hash-it"]
		var t,
			external_window_hash_it_default = __webpack_require__.n(
				external_window_hash_it_namespaceObject,
			)
		const external_window_micro_memoize_namespaceObject =
			window["micro-memoize"]
		var external_window_micro_memoize_default = __webpack_require__.n(
			external_window_micro_memoize_namespaceObject,
		)
		const getFlowChatProgress = animationState =>
				animationState.pipe(
					Either_match({ onLeft: Option_none, onRight: Option_some }),
					flatMapNullable(x => x.currentTime),
					map(x => ("number" == typeof x ? x : x.to("ms").value)),
					map(x => x / 6400),
					getOrElse(() => 0),
				),
			getFlowChatRect = (chat, config, playerRect) =>
				Function_pipe(
					config,
					x =>
						playerRect.width * x.flowX2 -
						(chat.width + playerRect.width * (x.flowX2 - x.flowX1)) *
							getFlowChatProgress(chat.animationState),
					x => new DOMRectReadOnly(x, chat.y, chat.width, chat.height),
				),
			getChatLane =
				(flowChat, chatIndex, progress) =>
				({ config: { value: config }, flowChats, playerRect }) =>
					Effect_gen(function* () {
						const rect = yield* SynchronizedRef_get(playerRect),
							flowWidth = rect.width * (config.flowX2 - config.flowX1),
							{
								width: chatWidth,
								height: chatHeight,
								x: chatX,
							} = getFlowChatRect(flowChat, config, rect),
							movingChats = Function_pipe(
								yield* SynchronizedRef_get(flowChats),
								chats =>
									Array_take(
										chats,
										getOrElse(chatIndex, () => chats.length),
									),
								Array_filter(
									chat => Either_isRight(chat.animationState) && chat.width > 0,
								),
								sort(Order_mapInput(x => x.lane)(Number_Order)),
							),
							tooCloseTo = external_window_micro_memoize_default()(
								x => {
									const { width: otherWidth, x: otherX } = getFlowChatRect(
											x,
											config,
											rect,
										),
										gap =
											(chatHeight * otherWidth * chatWidth) ** 0.333 *
											config.minSpacing
									return (
										(flowWidth - otherX) / (flowWidth + otherWidth) - progress <
											(chatWidth + gap) / (flowWidth + chatWidth) ||
										otherX + otherWidth + gap > chatX
									)
								},
								{ maxSize: 1e3 },
							),
							occupyInfo = Function_pipe(
								movingChats,
								Array_map(x => ({
									tooClose: () => tooCloseTo(x),
									lane: x.lane,
								})),
								Array_append({ tooClose: () => !0, lane: config.laneCount }),
							),
							index = Function_pipe(
								occupyInfo,
								findFirstIndex(x => x.lane >= flowChat.lane),
								getOrElse(() => -1),
							),
							nextOccupiedLaneAbove = Function_pipe(
								occupyInfo,
								Array_take(index),
								Array_findLast(x => x.tooClose()),
								map(x => x.lane),
								getOrElse(() => -1),
							),
							nextOccupiedLaneBelow = Function_pipe(
								occupyInfo,
								Array_drop(index),
								Array_findFirst(x => x.tooClose()),
								map(x => x.lane),
								getOrElse(() => config.laneCount),
							),
							formerLaneInterval = Math.min(
								flowChat.lane - nextOccupiedLaneAbove,
								nextOccupiedLaneBelow - flowChat.lane,
								1,
							)
						return Function_pipe(
							occupyInfo,
							Array_reduce(
								{ maxInterval: 0, maxIntervalLane: 0, lastLane: -1 },
								({ maxInterval, maxIntervalLane, lastLane }, info) =>
									maxInterval > 0.999 || !info.tooClose()
										? { maxInterval, maxIntervalLane, lastLane }
										: (() => {
												const nextLane = info.lane,
													interLane = Number_clamp({
														minimum: 0,
														maximum: config.laneCount - 1,
													})((lastLane + nextLane) / 2),
													newInterval = Math.min(
														interLane - lastLane,
														nextLane - interLane,
														1,
													)
												return {
													lastLane: nextLane,
													...(newInterval - maxInterval > 0.001
														? {
																maxInterval: newInterval,
																maxIntervalLane: Math.max(
																	lastLane + newInterval,
																	0,
																),
															}
														: { maxInterval, maxIntervalLane }),
												}
											})(),
							),
							x => ({
								lane:
									Math.abs(formerLaneInterval - x.maxInterval) < 0.001
										? flowChat.lane
										: x.maxIntervalLane,
								interval: x.maxInterval,
							}),
						)
					}),
			intervalTooSmall = interval => config =>
				config.noOverlap && interval < 0.999,
			setChatPlayState = chat => mainState =>
				Function_pipe(
					chat.animationState,
					Effect_tap(x =>
						SynchronizedRef_get(mainState.chatPlaying).pipe(
							Effect_flatMap(playing =>
								Effect_sync(playing ? () => x.play() : () => x.pause()),
							),
						),
					),
					Effect_flatMap(x =>
						Effect_sync(() => {
							x.playbackRate = mainState.config.value.flowSpeed / 15
						}),
					),
					Effect_ignore,
				),
			getWidth = external_window_micro_memoize_default()(
				ele => ele?.getBoundingClientRect().width ?? 0,
				{
					maxSize: 2e3,
					transformKey: Array_map(external_window_hash_it_default()),
				},
			),
			setChatAnimation = chat => mainState =>
				Function_pipe(
					getChatFontSize(mainState),
					Effect_tap(height =>
						Effect_gen(function* () {
							chat.element.style.transform = `translate(${(yield* SynchronizedRef_get(mainState.playerRect)).width * (mainState.config.value.flowX2 - mainState.config.value.flowX1)}px, -${2 * height}px)`
						}),
					),
					Effect_filterOrFail(() =>
						Either_match(chat.animationState, {
							onLeft: x => "NotStarted" === x,
							onRight: () => !0,
						}),
					),
					Effect_flatMap(height =>
						Effect_gen(function* () {
							return {
								newChat: {
									...chat,
									width: getWidth(chat.element.firstElementChild),
									height,
								},
								oldChatIndex: Function_pipe(
									yield* SynchronizedRef_get(mainState.flowChats),
									findFirstIndex(x => x === chat),
								),
								progress: getFlowChatProgress(chat.animationState),
							}
						}),
					),
					Effect_flatMap(ctx =>
						getChatLane(
							ctx.newChat,
							ctx.oldChatIndex,
							ctx.progress,
						)(mainState).pipe(
							Effect_flatMap(({ lane, interval }) =>
								intervalTooSmall(interval)(mainState.config.value)
									? ctx.newChat.animationState.pipe(
											Effect_tap(x => Effect_sync(() => x.finish())),
											Effect_map(() => ({
												...ctx.newChat,
												animationState: Either_left("Ended"),
											})),
											Effect_orElse(() => Effect_succeed(ctx.newChat)),
										)
									: (
											chat => lane => progress => mainState =>
												Function_pipe(
													((lane, { config: { value: config }, playerRect }) =>
														SynchronizedRef_get(playerRect).pipe(
															Effect_map(
																rect =>
																	rect.height *
																	((lane / config.laneCount + 0.005) *
																		(config.flowY2 - config.flowY1) +
																		config.flowY1),
															),
														))(lane, mainState),
													Effect_map(y => ({ ...chat, lane, y })),
													Effect_tap(newChat =>
														Function_pipe(
															newChat.animationState,
															Either_match({
																onLeft: () => _void,
																onRight: x => Effect_sync(() => x.cancel()),
															}),
														),
													),
													Effect_flatMap(newChat =>
														SynchronizedRef_get(mainState.playerRect).pipe(
															Effect_map(rect => [
																[
																	rect.width *
																		(mainState.config.value.flowX2 -
																			mainState.config.value.flowX1),
																	newChat.y,
																],
																[-newChat.width, newChat.y],
															]),
															Effect_map(
																Function_pipe(
																	x => `${x}px`,
																	x =>
																		Array_map(
																			mapBoth({ onFirst: x, onSecond: x }),
																		),
																),
															),
															Effect_map(
																Array_map(([x, y]) => ({
																	transform: `translate(${x}, ${y})`,
																})),
															),
															Effect_flatMap(x =>
																Effect_sync(() =>
																	newChat.element.animate(x, {
																		duration: 6400,
																		easing:
																			mainState.config.value.timingFunction,
																	}),
																),
															),
															Effect_flatMap(animation =>
																Effect_sync(() => {
																	const newNewChat = {
																		...newChat,
																		animationState: Either_right(animation),
																	}
																	Object.assign(animation, {
																		onfinish: () =>
																			Object.assign(newNewChat, {
																				animationState: Either_left("Ended"),
																			}),
																		currentTime: 6400 * progress,
																	})
																	return newNewChat
																}),
															),
														),
													),
												)
										)(ctx.newChat)(lane)(ctx.progress)(mainState),
							),
							Effect_map(x => ({ oldChatIndex: ctx.oldChatIndex, newChat: x })),
						),
					),
					Effect_tap(x => setChatPlayState(x.newChat)(mainState)),
					Effect_flatMap(x =>
						match(x.oldChatIndex, {
							onNone: () => Effect_succeed({ newChat: x.newChat }),
							onSome: index =>
								Function_pipe(
									SynchronizedRef_update(
										mainState.flowChats,
										Array_replace(index, x.newChat),
									),
									Effect_zipRight(
										Effect_fail(new Cause_NoSuchElementException()),
									),
								),
						}),
					),
				),
			tapEffect = f =>
				(0, external_rxjs_namespaceObject.concatMap)(x =>
					(0, external_rxjs_namespaceObject.from)(Effect_runPromise(f(x))).pipe(
						(0, external_rxjs_namespaceObject.map)(() => x),
					),
				),
			configStream = (provideLog, mainState, co, chatScreen, live) =>
				(0, external_rxjs_namespaceObject.defer)(() =>
					(0, external_rxjs_namespaceObject.merge)(
						(0, external_rxjs_namespaceObject.merge)(
							co.bannedWordRegexes,
							co.bannedWords,
							co.bannedUsers,
						),
						Function_pipe(
							co.fieldScale,
							(0, external_rxjs_namespaceObject.startWith)(
								mainState.config.value.fieldScale,
							),
							(0, external_rxjs_namespaceObject.map)(
								(
									live => scale =>
										Function_pipe(
											live.chatField.ele,
											Effect_flatMap(field =>
												Function_pipe(
													[
														Function_pipe(
															fromNullable(field.parentElement),
															map(x =>
																Effect_sync(() =>
																	Object.assign(x.style, {
																		transformOrigin:
																			(scale >= 1 ? "top" : "bottom") + " left",
																		transform: `scale(${scale})`,
																		width: 100 / scale + "%",
																		height: 100 / scale + "%",
																	}),
																),
															),
														),
														Function_pipe(
															live.chatScroller.ele,
															map(scroller =>
																Effect_sync(() => {
																	scroller.scrollTop = scroller.scrollHeight
																}),
															),
														),
													],
													Array_getSomes,
													Effect_all,
												),
											),
											Effect_ignore,
										)
								)(live),
							),
							tapEffect(provideLog),
						),
						Function_pipe(
							(0, external_rxjs_namespaceObject.merge)(
								Function_pipe(
									(0, external_rxjs_namespaceObject.merge)(
										co.displayModName,
										co.displaySuperChatAuthor,
										co.font,
										co.fontSize,
										co.fontWeight,
										co.laneCount,
										co.minSpacing,
										co.flowY1,
										co.flowY2,
										Function_pipe(
											co.flowX1,
											(0, external_rxjs_namespaceObject.startWith)(
												mainState.config.value.flowX1,
											),
											tapEffect(x =>
												provideLog(
													Effect_sync(() =>
														Object.assign(chatScreen.style, {
															left: 100 * x + "%",
															width:
																100 * (mainState.config.value.flowX2 - x) + "%",
														}),
													),
												),
											),
										),
										Function_pipe(
											co.flowX2,
											tapEffect(x =>
												provideLog(
													Effect_sync(() =>
														Object.assign(chatScreen.style, {
															left: 100 * mainState.config.value.flowX1 + "%",
															width:
																100 * (x - mainState.config.value.flowX1) + "%",
														}),
													),
												),
											),
										),
										co.textOnly,
									),
									(0, external_rxjs_namespaceObject.map)(() => ({
										render: !0,
										setAnimation: !0,
									})),
								),
								Function_pipe(
									(0, external_rxjs_namespaceObject.merge)(
										co.color,
										co.ownerColor,
										co.moderatorColor,
										co.memberColor,
										co.shadowColor,
										co.chatOpacity,
										co.shadowFontWeight,
										co.displayChats,
									),
									(0, external_rxjs_namespaceObject.map)(() => ({
										render: !0,
									})),
								),
								Function_pipe(
									co.flowSpeed,
									(0, external_rxjs_namespaceObject.map)(() => ({
										setPlayState: !0,
									})),
								),
								Function_pipe(
									(0, external_rxjs_namespaceObject.merge)(
										Function_pipe(
											co.maxChatCount,
											(0, external_rxjs_namespaceObject.map)(
												removeOldChats(mainState.flowChats),
											),
											tapEffect(provideLog),
										),
										co.noOverlap,
										co.timingFunction,
									),
									(0, external_rxjs_namespaceObject.map)(() => ({
										setAnimation: !0,
									})),
								),
							),
							(0, external_rxjs_namespaceObject.throttleTime)(180, void 0, {
								leading: !0,
								trailing: !0,
							}),
							(0, external_rxjs_namespaceObject.map)(x => ({
								render: !1,
								setAnimation: !1,
								setPlayState: !1,
								...x,
							})),
							tapEffect(c =>
								provideLog(
									Function_pipe(
										SynchronizedRef_get(mainState.flowChats),
										Effect_map(
											Array_filter(x => Either_isRight(x.animationState)),
										),
										Effect_flatMap(
											Effect_forEach(chat =>
												Function_pipe(
													Effect_allSuccesses([
														c.render
															? Effect_succeed(renderChat(chat))
															: Effect_fail(new Cause_NoSuchElementException()),
														c.setAnimation
															? Effect_succeed(state =>
																	Effect_ignore(setChatAnimation(chat)(state)),
																)
															: c.setPlayState
																? Effect_succeed(setChatPlayState(chat))
																: Effect_fail(
																		new Cause_NoSuchElementException(),
																	),
													]),
													Effect_flatMap(Effect_forEach(apply(mainState))),
												),
											),
										),
									),
								),
							),
						),
						co.lang,
						co.maxChatLength,
						co.simplifyChatField,
						co.createBanButton,
						co.createChats,
						co.fieldScale,
					),
				),
			src_listeningBroadcastConfigKeys = [
				"lang",
				"bannedWords",
				"bannedWordRegexes",
				"bannedUsers",
				"filterExp",
				"simplifyChatField",
				"createBanButton",
				"fieldScale",
			],
			chatApp = Function_pipe(
				Effect_sync(() => document.querySelector("#chatframe")),
				Effect_flatMap(nullableFrame =>
					Function_pipe(
						fromNullable(nullableFrame),
						filter(frame =>
							Function_pipe(
								frame.contentDocument?.readyState,
								x => "loading" === x || "complete" === x,
							),
						),
						flatMapNullable(x => x.contentDocument),
						orElse(() => Option_some(document)),
						flatMapNullable(x => x.querySelector("yt-live-chat-app")),
					),
				),
			),
			livePageYt = {
				toggleChatBtnParent: Function_pipe(
					Effect_sync(() =>
						Array.from(document.querySelectorAll(".ytp-right-controls")),
					),
					Effect_flatMap(Array_findFirst(x => null !== x.offsetParent)),
				),
				settingsToggleNextElement: Function_pipe(
					Effect_sync(() => document.querySelector("#menu-container")),
					Effect_flatMap(Effect_fromNullable),
					Effect_filterOrFail(x => null !== x.offsetParent),
					Effect_flatMap(x =>
						Effect_fromNullable(
							x.querySelector(".dropdown-trigger.ytd-menu-renderer"),
						),
					),
					Effect_orElse(() =>
						Effect_fromNullable(
							document.querySelector(
								"#top-row .dropdown-trigger.ytd-menu-renderer",
							),
						),
					),
					Effect_filterOrFail(x => null !== x.parentElement?.offsetParent),
				),
				settingsContainer: Function_pipe(
					Effect_sync(() => document.body),
					Effect_flatMap(fromNullable),
				),
				player: Function_pipe(
					Effect_sync(() => document.querySelector("#movie_player")),
					Effect_flatMap(fromNullable),
				),
				video: Function_pipe(
					Effect_sync(() =>
						document.querySelector("video.video-stream.html5-main-video"),
					),
					Effect_flatMap(fromNullable),
				),
				chatField: Function_pipe(
					chatApp,
					Effect_flatMap(app =>
						Function_pipe(
							app.querySelector("#items.yt-live-chat-item-list-renderer"),
							fromNullable,
						),
					),
				),
				chatTicker: Function_pipe(
					chatApp,
					Effect_flatMap(app =>
						Function_pipe(
							app.querySelector("#items.yt-live-chat-ticker-renderer"),
							fromNullable,
						),
					),
				),
				chatScroller: Function_pipe(
					chatApp,
					Effect_flatMap(app =>
						Function_pipe(
							app.querySelector(
								"#item-scroller.yt-live-chat-item-list-renderer",
							),
							fromNullable,
						),
					),
				),
				offlineSlate: Function_pipe(
					Effect_sync(() => document.querySelector(".ytp-offline-slate")),
					Effect_flatMap(fromNullable),
				),
			},
			logMeta = fiberRefUnsafeMake(Option_none()),
			logWithMeta = level => message => data =>
				Function_pipe(
					Effect_log(message),
					Effect_locally(logMeta, Option_some(data)),
					x => locally(level)(x),
				),
			mainCss = Function_pipe(
				Effect_sync(() => document.createElement("style")),
				Effect_tap(x =>
					Effect_sync(() => {
						x.textContent =
							".fyc_chat {\n  line-height: 1;\n  z-index: 30;\n  position: absolute;\n  user-select: none;\n  white-space: nowrap;\n  will-change: transform;\n}\n.fyc_button {\n  display: inline-block;\n  border-style: none;\n  z-index: 4;\n  font-weight: 500;\n  color: var(--yt-spec-text-secondary);\n}"
					}),
				),
			),
			observePair = con =>
				Effect_sync(() => {
					const subject = new external_rxjs_namespaceObject.Subject()
					return { subject, observer: new con(lib(subject)) }
				}),
			emptyElement = document.createElement("span"),
			addFlowChat = (data, chatScrn, mainState) =>
				Effect_gen(function* () {
					const chatFontSize = yield* getChatFontSize(mainState)
					;(yield* Function_pipe(
						Effect_succeed({
							data,
							element: emptyElement,
							lane: -1,
							animationState: Either_left("NotStarted"),
							width: 2,
							height: chatFontSize,
							y: 0,
						}),
						Effect_flatMap(x => getChatLane(x, Option_none(), 0)(mainState)),
						Effect_map(
							({ interval }) =>
								!intervalTooSmall(interval)(mainState.config.value),
						),
					)) &&
						(yield* Function_pipe(
							SynchronizedRef_get(mainState.flowChats),
							Effect_flatMap(chats =>
								findFirstIndex(
									chats,
									chat =>
										Either_match(chat.animationState, {
											onLeft: x => "Ended" === x,
											onRight: () => !1,
										}) || chats.length >= mainState.config.value.maxChatCount,
								),
							),
							Effect_matchEffect({
								onFailure: () =>
									Function_pipe(
										Effect_sync(() => document.createElement("span")),
										Effect_tap(element =>
											Effect_sync(() => chatScrn.append(element)),
										),
										Effect_tap(element =>
											Effect_sync(() => element.classList.add("fyc_chat")),
										),
										Effect_zipLeft(Effect_logDebug("Flow chat element added")),
									),
								onSuccess: index =>
									Function_pipe(
										Effect_gen(function* () {
											const chat = Function_pipe(
												yield* SynchronizedRef_get(mainState.flowChats),
												Array_unsafeGet(index),
											)
											yield* SynchronizedRef_update(
												mainState.flowChats,
												Array_remove(index),
											)
											yield* chat.animationState.pipe(
												Effect_tap(animation =>
													Effect_sync(() => animation.cancel()),
												),
												Effect_ignore,
											)
											return chat.element
										}),
									),
							}),
							Effect_map(element => ({
								data,
								element,
								lane: -1,
								animationState: Either_left("NotStarted"),
								width: 2,
								height: chatFontSize,
								y: 0,
							})),
							Effect_flatMap(flowChat =>
								Function_pipe(
									Effect_succeed(mainState),
									Effect_tap(renderChat(flowChat)),
									Effect_flatMap(setChatAnimation(flowChat)),
									Effect_matchEffect({
										onFailure: () =>
											Function_pipe(
												Effect_sync(() => flowChat.element.remove()),
												Effect_zipLeft(
													Effect_logDebug("Flow chat element removed"),
												),
											),
										onSuccess: x =>
											SynchronizedRef_update(
												mainState.flowChats,
												Array_append(x.newChat),
											),
									}),
								),
							),
						))
				}),
			appendChatMessage = flip(chat =>
				Effect_flatMap(x =>
					Effect_sync(() => chat.querySelector("#content #message")?.append(x)),
				),
			),
			template = Effect_runPromise(
				Function_pipe(
					Effect_succeed(document.createElement("button")),
					Effect_tap(x =>
						Effect_sync(() =>
							x.classList.add("style-scope", "yt-icon-button", "fyc_button"),
						),
					),
					Effect_tap(x =>
						Effect_sync(() =>
							Object.assign(x.style, {
								padding: "0px",
								width: "20px",
								height: "20px",
								fill: "#fff",
							}),
						),
					),
					Effect_tap(x =>
						Effect_sync(() =>
							x.setAttribute("aria-label", "NGに入れる(Ban this user)"),
						),
					),
					Effect_tap(x =>
						Effect_sync(() => {
							const svg = document.createElementNS(
								"http://www.w3.org/2000/svg",
								"svg",
							)
							svg.setAttribute("class", "style-scope yt-icon")
							Object.assign(svg.style, {
								width: "100%",
								height: "75%",
								fill: "var(--yt-spec-text-secondary)",
							})
							svg.setAttribute("viewBox", "0 0 512 512")
							const path = document.createElementNS(
								"http://www.w3.org/2000/svg",
								"path",
							)
							path.setAttribute(
								"d",
								"M440 78A256 256 0 1 0 73 435 256 256 0 0 0 440 78zm-99 35L113 341C37 179 212 44 341 113zM177 405l228-228c76 162-99 297-228 228z",
							)
							path.setAttribute("fill-rule", "evenodd")
							svg.appendChild(path)
							x.appendChild(svg)
						}),
					),
				),
			),
			fromSemigroup = (S, empty) => ({
				combine: S.combine,
				combineMany: S.combineMany,
				empty,
				combineAll: collection => S.combineMany(empty, collection),
			}),
			Semigroup_make = (
				combine,
				combineMany = (self, collection) => {
					return ((b = self),
					(f = combine),
					function (iterable) {
						if (Array.isArray(iterable)) return iterable.reduce(f, b)
						let result = b
						for (const n of iterable) result = f(result, n)
						return result
					})(collection)
					var b, f
				},
			) => ({ combine, combineMany }),
			SemigroupEvery = Semigroup_make(
				(self, that) => self && that,
				(self, collection) => {
					if (!1 === self) return !1
					for (const b of collection) if (!1 === b) return !1
					return !0
				},
			),
			SemigroupSome = Semigroup_make(
				(self, that) => self || that,
				(self, collection) => {
					if (!0 === self) return !0
					for (const b of collection) if (!0 === b) return !0
					return !1
				},
			),
			MonoidEvery = fromSemigroup(SemigroupEvery, !0),
			MonoidSome = fromSemigroup(SemigroupSome, !1),
			filter_filterOperators = {
				flip,
				flow: fns => x => Function_pipe(x, ...fns),
				and: MonoidEvery.combineAll,
				or: MonoidSome.combineAll,
				A: { some: Array_some, getSomes: Array_getSomes },
				O: { exists },
				inText: text => x => {
					return ((searchString = x),
					self => self.includes(searchString, void 0))(text)
					var searchString
				},
				eqText: text => x => text === x,
				matchedByText: text => x => isTruthy(text.match(RegExp(x, "u"))),
			},
			setChatFieldSimplifyStyle = chat =>
				Effect_gen(function* () {
					chat.querySelector(
						".style-scope.yt-live-chat-paid-message-renderer",
					) ||
						(yield* Function_pipe(
							[
								"#author-photo",
								"yt-live-chat-author-chip.style-scope.yt-live-chat-text-message-renderer",
							],
							Array_map(x => fromNullable(chat.querySelector(x))),
							Array_getSomes,
							Array_map(x =>
								Effect_sync(() => {
									x.style.display = "none"
								}),
							),
							Array_append(
								Effect_sync(() => {
									chat.style.borderBottom =
										"1px solid var(--yt-spec-text-secondary)"
								}),
							),
							Effect_all,
						))
				}),
			strictOptionEquivalence =
				((isEquivalent = strict()),
				Equivalence_make((x, y) =>
					Option_isNone(x)
						? Option_isNone(y)
						: !Option_isNone(y) && isEquivalent(x.value, y.value),
				)),
			allStream = provideLog =>
				(function (ab, bc, cd, de, ef, fg, gh, hi, ij) {
					switch (arguments.length) {
						case 1:
							return ab
						case 2:
							return function () {
								return bc(ab.apply(this, arguments))
							}
						case 3:
							return function () {
								return cd(bc(ab.apply(this, arguments)))
							}
						case 4:
							return function () {
								return de(cd(bc(ab.apply(this, arguments))))
							}
						case 5:
							return function () {
								return ef(de(cd(bc(ab.apply(this, arguments)))))
							}
						case 6:
							return function () {
								return fg(ef(de(cd(bc(ab.apply(this, arguments))))))
							}
						case 7:
							return function () {
								return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))
							}
						case 8:
							return function () {
								return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))
							}
						case 9:
							return function () {
								return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))))
							}
					}
				})(
					ctx =>
						Effect_gen(function* () {
							const live = makePageState(livePageYt)
							return {
								...ctx,
								live,
								...Function_pipe(
									new external_rxjs_namespaceObject.BehaviorSubject(
										new DOMRectReadOnly(0, 0, 660, 395),
									),
									settingsRectSubject => ({
										settingsRectSubject,
										tapUpdateSettingsRect: ob =>
											(0, external_rxjs_namespaceObject.switchMap)(value => {
												return Function_pipe(
													settingsRectSubject,
													(0, external_rxjs_namespaceObject.first)(),
													(0, external_rxjs_namespaceObject.map)(
														((toggleSettingsElement =
															ctx.apps.toggleSettingsPanelApp.node),
														nextSettingsRect => last =>
															Function_pipe(
																Effect_succeed(toggleSettingsElement),
																Effect_filterOrFail(
																	x => null !== x.offsetParent,
																),
																Effect_map(x => x.getBoundingClientRect()),
																Effect_map(
																	x =>
																		new DOMRectReadOnly(
																			Math.max(
																				0,
																				x.right + window.scrollX - 660,
																			),
																			Math.max(0, x.y + window.scrollY - 395),
																			660,
																			Math.min(x.y + window.scrollY, 395),
																		),
																),
																Effect_orElseSucceed(
																	() =>
																		new DOMRectReadOnly(-660, -395, 660, 395),
																),
																Effect_filterOrFail(
																	x =>
																		x.x !== last.x ||
																		x.y !== last.y ||
																		x.width !== last.width ||
																		x.height !== last.height,
																),
																Effect_tap(nextSettingsRect),
																Effect_ignore,
															))(rect =>
															Effect_sync(() => settingsRectSubject.next(rect)),
														),
													),
													tapEffect(provideLog),
													(0, external_rxjs_namespaceObject.map)(() => value),
												)
												var toggleSettingsElement
											})(ob),
									}),
								),
								config$: configStream(
									provideLog,
									ctx.mainState,
									ctx.co,
									ctx.chatScreen,
									live,
								),
								css: yield* mainCss,
								documentMutationPair: yield* observePair(MutationObserver),
								chatMutationPair: yield* observePair(MutationObserver),
								playerResizePair: yield* observePair(ResizeObserver),
								bodyResizePair: yield* observePair(ResizeObserver),
								liveElementKeys: Object.keys(live),
							}
						}),
					Effect_map(c =>
						Function_pipe(
							c.reinitSubject,
							(0, external_rxjs_namespaceObject.observeOn)(
								external_rxjs_namespaceObject.asyncScheduler,
							),
							Function_pipe(Duration_millis(100), initDelay =>
								(0, external_rxjs_namespaceObject.delay)(toMillis(initDelay)),
							),
							tapEffect(() => provideLog(Effect_logInfo("Init"))),
							(0, external_rxjs_namespaceObject.switchMap)(() =>
								Function_pipe(
									Duration_millis(700),
									changeDetectInterval =>
										(0, external_rxjs_namespaceObject.interval)(
											toMillis(changeDetectInterval),
										),
									c.tapUpdateSettingsRect,
									(0, external_rxjs_namespaceObject.concatMap)(index =>
										Function_pipe(
											(0, external_rxjs_namespaceObject.from)(
												Effect_runPromise(
													provideLog(
														Function_pipe(
															Effect_succeed(c.liveElementKeys),
															Effect_flatMap(
																Effect_forEach(key =>
																	c.live[key].read.pipe(
																		Effect_option,
																		Effect_flatMap(
																			liftPredicate(
																				newEle =>
																					!strictOptionEquivalence(
																						c.live[key].ele,
																						newEle,
																					),
																			),
																		),
																		Effect_tap(x =>
																			Effect_sync(() => {
																				c.live[key].ele = x
																			}),
																		),
																		Effect_map(Option_isSome),
																		Effect_map(
																			x => `${key} ${x ? "found" : "lost"}`,
																		),
																		Effect_flatMap(Effect_logDebug),
																		Effect_isSuccess,
																	),
																),
															),
															Effect_map(Array_some(Function_identity)),
														),
													),
												),
											),
											(0, external_rxjs_namespaceObject.filter)(
												Function_identity,
											),
											(0, external_rxjs_namespaceObject.map)(() => index),
										),
									),
									(0, external_rxjs_namespaceObject.startWith)(0),
								),
							),
							tapEffect(() =>
								provideLog(
									Function_pipe(
										Effect_logDebug("Loading..."),
										Effect_zipRight(
											Effect_sync(() => {
												;[
													c.documentMutationPair,
													c.chatMutationPair,
													c.playerResizePair,
													c.bodyResizePair,
												].forEach(pair => {
													pair.observer.disconnect()
												})
												c.documentMutationPair.observer.observe(document, {
													childList: !0,
													subtree: !0,
												})
												document.head.append(c.css)
											}),
										),
										Effect_zipRight(
											Effect_allSuccesses([
												...Array_map(
													[c.live.chatField.ele, c.live.chatTicker.ele],
													Effect_flatMap(x =>
														Effect_sync(() =>
															c.chatMutationPair.observer.observe(x, {
																childList: !0,
															}),
														),
													),
												),
												c.live.player.ele.pipe(
													Effect_flatMap(element =>
														Function_pipe(
															Effect_succeed(element),
															Effect_tap(x =>
																Effect_sync(() =>
																	c.playerResizePair.observer.observe(x),
																),
															),
															Effect_flatMap(x =>
																Effect_sync(() => x.prepend(c.chatScreen)),
															),
														),
													),
												),
												c.live.toggleChatBtnParent.ele.pipe(
													Effect_flatMap(x =>
														Effect_sync(() =>
															x.prepend(c.apps.toggleChatButtonApp.node),
														),
													),
												),
												c.live.settingsToggleNextElement.ele.pipe(
													Effect_flatMap(x =>
														Effect_sync(() =>
															x.before(c.apps.toggleSettingsPanelApp.node),
														),
													),
													Effect_orElse(() =>
														c.live.toggleChatBtnParent.ele.pipe(
															Effect_flatMap(() =>
																Effect_sync(() =>
																	c.apps.toggleChatButtonApp.node.before(
																		c.apps.toggleSettingsPanelApp.node,
																	),
																),
															),
														),
													),
												),
												c.live.settingsContainer.ele.pipe(
													Effect_flatMap(x =>
														Effect_sync(() =>
															x.append(c.apps.settingsApp.node),
														),
													),
												),
												Function_pipe(
													document.body,
													Effect_fromNullable,
													Effect_flatMap(x =>
														Effect_sync(() =>
															c.bodyResizePair.observer.observe(x),
														),
													),
												),
												c.live.video.ele.pipe(
													Effect_filterOrElse(
														x => !x.paused,
														() => c.live.offlineSlate.ele,
													),
													Effect_isSuccess,
													Effect_flatMap(x =>
														SynchronizedRef_set(c.mainState.chatPlaying, x),
													),
												),
											]),
										),
									),
								),
							),
							(0, external_rxjs_namespaceObject.switchMap)(() => {
								return (0, external_rxjs_namespaceObject.merge)(
									Function_pipe(
										(0, external_rxjs_namespaceObject.fromEvent)(
											c.channel,
											"message",
										),
										(0, external_rxjs_namespaceObject.map)(([key, val]) =>
											Function_pipe(
												src_listeningBroadcastConfigKeys.includes(key),
												x =>
													x
														? c.setChangedConfig[key](val)
														: Effect_sync(() => {}),
											),
										),
										tapEffect(provideLog),
									),
									...Function_pipe(
										configKeys,
										Array_map(key =>
											Function_pipe(
												c.co[key],
												(0, external_rxjs_namespaceObject.startWith)(
													c.mainState.config.value[key],
												),
												(0, external_rxjs_namespaceObject.bufferCount)(2, 1),
												(0, external_rxjs_namespaceObject.map)(([x, y]) =>
													(0, external_DeepDiff_namespaceObject.diff)(x, y),
												),
												(0, external_rxjs_namespaceObject.map)(x =>
													Effect_logDebug(
														`Config ${key}: ${JSON.stringify(x, void 0, 2)}`,
													),
												),
												tapEffect(provideLog),
											),
										),
									),
									c.config$,
									c.live.video.ele.pipe(
										match({
											onNone: () => external_rxjs_namespaceObject.EMPTY,
											onSome: element => {
												return Function_pipe(
													((video = element),
													Function_pipe(
														[["playing"], ["waiting", "pause"]],
														Array_map((x, i) => [x, 0 === i]),
														Array_flatMap(([xs, b]) =>
															Function_pipe(
																xs,
																Array_map(x => [x, b]),
															),
														),
														Array_map(([x, b]) =>
															Function_pipe(
																(0, external_rxjs_namespaceObject.fromEvent)(
																	video,
																	x,
																),
																(0, external_rxjs_namespaceObject.map)(() => b),
															),
														),
														x => (0, external_rxjs_namespaceObject.merge)(...x),
													)),
													(0, external_rxjs_namespaceObject.map)(
														playing =>
															playing || Option_isSome(c.live.offlineSlate.ele),
													),
													(0, external_rxjs_namespaceObject.map)(chatPlaying =>
														Function_pipe(
															SynchronizedRef_set(
																c.mainState.chatPlaying,
																chatPlaying,
															),
															Effect_zipRight(
																Function_pipe(
																	SynchronizedRef_get(c.mainState.flowChats),
																	Effect_map(Array_map(setChatPlayState)),
																	Effect_flatMap(
																		Effect_forEach(apply(c.mainState)),
																	),
																),
															),
														),
													),
													tapEffect(provideLog),
												)
												var video
											},
										}),
									),
									Function_pipe(
										c.chatMutationPair.subject,
										(0, external_rxjs_namespaceObject.map)(
											((chatScrn = c.chatScreen),
											(mainState = c.mainState),
											records =>
												Function_pipe(
													Effect_succeed(records),
													Effect_map(
														Array_flatMap(e => Array.from(e.addedNodes)),
													),
													Effect_map(Array_filter(x => x.children.length > 0)),
													Effect_map(Array_reverse),
													Effect_flatMap(
														Effect_forEach(chat =>
															Effect_gen(function* () {
																yield* Effect_logDebug("Chat detected")
																const data = (chat => {
																	const chatType = chat.querySelector(
																			".yt-live-chat-ticker-paid-message-item-renderer",
																		)
																			? "ticker"
																			: chat.querySelector(
																						".yt-live-chat-membership-item-renderer",
																				  )
																				? "membership"
																				: chat.querySelector(
																							".yt-live-chat-viewer-engagement-message-renderer",
																					  )
																					? "engagement"
																					: "normal",
																		paymentInfo = Function_pipe(
																			"ticker" === chatType ||
																				null !== chat.querySelector("#card"),
																			isPaid =>
																				fromNullable(
																					isPaid
																						? chat.querySelector(
																								join(", ")([
																									"#purchase-amount",
																									"#purchase-amount-chip",
																									"#content>#text",
																								]),
																							)?.textContent
																						: void 0,
																				),
																		),
																		messageElement = fromNullable(
																			chat.querySelector("#message"),
																		),
																		isPaidNormal =
																			Option_isSome(paymentInfo) &&
																			isTruthy(
																				chat.querySelector(
																					".yt-live-chat-paid-message-renderer",
																				),
																			),
																		isPaidSticker =
																			Option_isSome(paymentInfo) &&
																			!isPaidNormal &&
																			isTruthy(
																				chat.querySelector(
																					".yt-live-chat-paid-sticker-renderer",
																				),
																			),
																		visibleBackgroundColor = element =>
																			Function_pipe(
																				window
																					.getComputedStyle(element)
																					.getPropertyValue("background-color"),
																				liftPredicate(
																					x =>
																						"transparent" !== x &&
																						"rgba(0, 0, 0, 0)" !== x,
																				),
																			)
																	return {
																		chatType,
																		authorType: chat.querySelector(".owner")
																			? "owner"
																			: chat.querySelector(".moderator")
																				? "moderator"
																				: chat.querySelector(".member")
																					? "member"
																					: "normal",
																		authorID: Function_pipe(
																			chat
																				.querySelector(
																					join(" ")(["#author-photo", "img"]),
																				)
																				?.src.match(
																					/ggpht\.com\/(ytc\/)?(.*)=/,
																				),
																			authorPhotoMatches =>
																				fromNullable(
																					authorPhotoMatches?.at(-1),
																				),
																		),
																		authorName: fromNullable(
																			chat.querySelector("#author-name")
																				?.textContent,
																		),
																		timestamp: fromNullable(
																			chat.querySelector("#timestamp")
																				?.textContent,
																		),
																		messageElement,
																		message: Function_pipe(
																			messageElement,
																			map(x => x.innerHTML),
																		),
																		messageText: Function_pipe(
																			messageElement,
																			map(x => x.textContent ?? ""),
																		),
																		paymentInfo,
																		textColor: isPaidNormal
																			? Function_pipe(
																					fromNullable(
																						chat.querySelector("#header"),
																					),
																					flatMap(visibleBackgroundColor),
																					orElse(() =>
																						Function_pipe(
																							fromNullable(
																								chat.querySelector("#card"),
																							),
																							flatMap(visibleBackgroundColor),
																						),
																					),
																					orElse(() =>
																						Function_pipe(
																							fromNullable(
																								chat.querySelector("#content"),
																							),
																							flatMap(visibleBackgroundColor),
																						),
																					),
																				)
																			: isPaidSticker
																				? Option_some(
																						window
																							.getComputedStyle(chat)
																							.getPropertyValue(
																								"--yt-live-chat-paid-sticker-chip-background-color",
																							),
																					)
																				: Option_none(),
																		paidColor: isPaidNormal
																			? Function_pipe(
																					fromNullable(
																						chat.querySelector("#content"),
																					),
																					flatMap(visibleBackgroundColor),
																					orElse(() =>
																						Function_pipe(
																							fromNullable(
																								chat.querySelector("#card"),
																							),
																							flatMap(visibleBackgroundColor),
																						),
																					),
																					orElse(() =>
																						Function_pipe(
																							fromNullable(
																								chat.querySelector("#header"),
																							),
																							flatMap(visibleBackgroundColor),
																						),
																					),
																				)
																			: isPaidSticker
																				? Option_some(
																						window
																							.getComputedStyle(chat)
																							.getPropertyValue(
																								"--yt-live-chat-paid-sticker-background-color",
																							),
																					)
																				: Option_none(),
																	}
																})(chat)
																;(yield* ((data, config) =>
																	Function_pipe(
																		Effect_succeed(data),
																		Effect_filterOrFail(x =>
																			a(
																				config.filterExp,
																				(data => ({
																					...filter_filterOperators,
																					authorName: data.authorName,
																					message: data.message,
																					messageText: data.messageText,
																					paymentInfo: data.paymentInfo,
																					authorID: data.authorID,
																				}))(x),
																			),
																		),
																		Effect_map(x => [x.message, x.paymentInfo]),
																		Effect_flatMap(
																			Effect_forEach(
																				Effect_orElse(() => Effect_succeed("")),
																			),
																		),
																		Effect_map(JSON.stringify),
																		Effect_flatMap(x =>
																			Effect_logDebug(`Filtered: ${x}`),
																		),
																		Effect_isSuccess,
																	))(data, mainState.config.value))
																	? (chat.style.display = "none")
																	: yield* Effect_all(
																			[
																				Function_pipe(
																					addFlowChat(
																						data,
																						chatScrn,
																						mainState,
																					),
																					Effect_when(
																						Function_pipe(
																							yield* SynchronizedRef_get(
																								mainState.flowChats,
																							),
																							flowChats => () =>
																								mainState.config.value
																									.createChats &&
																								"normal" === data.chatType &&
																								!Array_some(
																									flowChats,
																									x =>
																										Either_isRight(
																											x.animationState,
																										) &&
																										strictOptionEquivalence(
																											x.data.authorID,
																											data.authorID,
																										) &&
																										strictOptionEquivalence(
																											x.data.messageText,
																											data.messageText,
																										) &&
																										strictOptionEquivalence(
																											x.data.timestamp,
																											data.timestamp,
																										),
																								),
																						),
																					),
																				),
																				data.authorID.pipe(
																					filter(
																						() =>
																							mainState.config.value
																								.createBanButton &&
																							!chat.children.namedItem("card"),
																					),
																					Effect_flatMap(x => {
																						return appendChatMessage(
																							((id = x),
																							getConfig => setConfig => chat =>
																								Function_pipe(
																									getConfig.bannedUsers,
																									Effect_filterOrFail(
																										x => !x.includes(id),
																									),
																									Effect_map(x =>
																										Function_pipe(
																											dedupeWith(
																												x,
																												String_Equivalence,
																											),
																											Array_append(id),
																										),
																									),
																									Effect_flatMap(x =>
																										Function_pipe(
																											setConfig.bannedUsers(x),
																										),
																									),
																									Effect_ignore,
																									Effect_zipRight(
																										Effect_sync(() => {
																											chat.style.display =
																												"none"
																										}),
																									),
																									onclick =>
																										Function_pipe(
																											Effect_promise(
																												() => template,
																											),
																											Effect_map(x =>
																												x.cloneNode(!0),
																											),
																											Effect_tap(x =>
																												Effect_sync(() => {
																													x.onclick = () =>
																														Effect_runPromise(
																															onclick,
																														)
																												}),
																											),
																										),
																								))(mainState.config.getConfig)(
																								mainState.config.setConfig,
																							)(chat),
																						)(chat)
																						var id
																					}),
																					Effect_zipLeft(
																						Effect_logDebug("Ban button added"),
																					),
																				),
																				Function_pipe(
																					setChatFieldSimplifyStyle(chat),
																					Effect_when(
																						() =>
																							mainState.config.value
																								.simplifyChatField,
																					),
																					Effect_zipLeft(
																						Effect_logDebug("Chat simplified"),
																					),
																				),
																			],
																			{ mode: "either" },
																		)
															}),
														),
													),
												)),
										),
										tapEffect(provideLog),
									),
									Function_pipe(
										c.documentMutationPair.subject,
										(0, external_rxjs_namespaceObject.map)(
											() => window.location.href,
										),
										(0, external_rxjs_namespaceObject.distinctUntilChanged)(),
										(0, external_rxjs_namespaceObject.skip)(1),
										c.tapUpdateSettingsRect,
										(0, external_rxjs_namespaceObject.map)(x =>
											Effect_all([
												Effect_logDebug(`URL Changed: ${x}`),
												removeOldChats(c.mainState.flowChats)(0),
											]),
										),
										tapEffect(provideLog),
										Function_pipe(Duration_millis(1700), urlDelay =>
											(0, external_rxjs_namespaceObject.delay)(
												toMillis(urlDelay),
											),
										),
										tapEffect(() => c.reinitialize),
									),
									Function_pipe(
										c.playerResizePair.subject,
										(0, external_rxjs_namespaceObject.throttleTime)(
											500,
											void 0,
											{ leading: !0, trailing: !0 },
										),
										(0, external_rxjs_namespaceObject.startWith)([]),
										(0, external_rxjs_namespaceObject.map)(() =>
											c.live.player.ele.pipe(
												map(x => x.getBoundingClientRect()),
												match({
													onNone: () => _void,
													onSome: x => {
														return (
															(rect = x),
															(mainState = c.mainState),
															Function_pipe(
																Effect_succeed(rect),
																Effect_tap(x =>
																	Effect_logDebug(
																		`Resize [${x.width.toFixed(1)}, ${x.height.toFixed(1)}]`,
																	),
																),
																Effect_flatMap(r =>
																	SynchronizedRef_set(mainState.playerRect, r),
																),
																Effect_zipRight(
																	SynchronizedRef_get(mainState.flowChats),
																),
																Effect_flatMap(
																	Effect_forEach(x =>
																		Effect_all([
																			renderChat(x)(mainState),
																			Effect_ignore(
																				setChatAnimation(x)(mainState),
																			),
																		]),
																	),
																),
															)
														)
														var rect, mainState
													},
												}),
											),
										),
										tapEffect(provideLog),
									),
									Function_pipe(
										c.bodyResizePair.subject,
										Function_pipe(
											Duration_millis(300),
											bodyResizeDetectInterval =>
												(0, external_rxjs_namespaceObject.throttleTime)(
													toMillis(bodyResizeDetectInterval),
													void 0,
													{ leading: !0, trailing: !0 },
												),
										),
										(0, external_rxjs_namespaceObject.startWith)([]),
										c.tapUpdateSettingsRect,
									),
									Function_pipe(
										c.settingsRectSubject,
										tapEffect(panelRect =>
											c.updateSettingState(s => ({ ...s, panelRect })),
										),
									),
								)
								var chatScrn, mainState
							}),
							(0, external_rxjs_namespaceObject.retry)({
								delay: e =>
									Function_pipe(
										(0, external_rxjs_namespaceObject.of)(e),
										tapEffect(() =>
											provideLog(
												logWithMeta(LogLevel_Error)(`Errored: ${e}`)(e),
											),
										),
										Function_pipe(Duration_millis(5e3), errorRetryInterval =>
											(0, external_rxjs_namespaceObject.delay)(
												toMillis(errorRetryInterval),
											),
										),
										tapEffect(() => c.reinitialize),
									),
							}),
						),
					),
				),
			defaultFilter = config =>
				external_jsep_default()(
					`\nor([\nA.some(\n  flip(flow([inText, A.some]))(${JSON.stringify(config.bannedWords)})\n)(A.getSomes([\n  messageText,\n  paymentInfo\n])),\nA.some(\n  flip(flow([matchedByText, A.some]))(${JSON.stringify(config.bannedWordRegexes)})\n)(A.getSomes([\n  messageText,\n  paymentInfo\n])),\nO.exists(\n  flip(flow([eqText, A.some]))(${JSON.stringify(config.bannedUsers)})\n)(authorID)\n])\n`,
				),
			makeChatScreen = Function_pipe(
				Effect_sync(() => document.createElement("div")),
				Effect_tap(x =>
					Effect_sync(() =>
						Object.assign(x.style, {
							pointerEvents: "none",
							zIndex: "30",
							position: "absolute",
							overflow: "hidden",
							height: "100%",
							width: "100%",
						}),
					),
				),
			),
			Editable_of = x => [x, Option_none()],
			fromValueText = v => t => [v, Option_some([t, Option_none()])],
			Editable_value = getFirst,
			Editable_text = x => Function_pipe(getSecond(x), map(getFirst)),
			Editable_error = x => Function_pipe(getSecond(x), flatMap(getSecond)),
			setValue = v => Function_pipe(constant(v), x => mapFirst(x)),
			setText = x =>
				mapSecond(snd =>
					snd.pipe(
						map(mapFirst(constant(x))),
						orElse(constant(Option_some([x, Option_none()]))),
					),
				),
			hasError = x => Option_isSome(Editable_error(x)),
			exceptions = ["timingFunction", "lang"],
			isEditable = k => v =>
				("number" == typeof v ||
					"string" == typeof v ||
					(Array.isArray(v) && ("string" == typeof v[0] || 0 === v.length))) &&
				!Array_some(x => x === k)(exceptions),
			RefinedConstructorsTypeId = Symbol.for("effect/Brand/Refined")
		var isEquivalent
		const nominal = () =>
				Object.assign(args => args, {
					[RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
					option: args => Option_some(args),
					either: args => Either_right(args),
					is: _args => !0,
				}),
			external_LZString_namespaceObject = LZString,
			makeCompressedLogBlock = nominal(),
			makeLog = nominal(),
			decompressBlock = x =>
				Function_pipe(
					(0, external_LZString_namespaceObject.decompressFromUTF16)(x),
					JSON.parse,
				),
			importLog = s =>
				makeLog(
					Function_pipe(
						"<" === s[0] ? s.slice(5, -6) : s,
						x => JSON.parse(x),
						log => ({
							nextId: log.nextId,
							...Function_pipe(
								log.blocks,
								Array_map(
									external_LZString_namespaceObject.decompressFromEncodedURIComponent,
								),
								matchRight({
									onEmpty: () => ({ compressedBlocks: [], lastBlock: [] }),
									onNonEmpty: (init, last) => ({
										compressedBlocks: Array_map(init, x =>
											Function_pipe(
												(0, external_LZString_namespaceObject.compressToUTF16)(
													x,
												),
												makeCompressedLogBlock,
											),
										),
										lastBlock: JSON.parse(last),
									}),
								}),
							),
						}),
					),
				),
			makeComponent = x => tag => ({ tag, view: x(tag) }),
			node_option = (value, label, selected) =>
				h("option", { value, selected }, hyperapp_text(label)),
			tabContainer = style => ontabSelect => labels => tabs => mainTab =>
				h("div", { style: style.container }, [
					h(
						"div",
						{},
						Function_pipe(
							labels,
							Array_map((x, i) =>
								h(
									"span",
									{
										style: {
											...style.label,
											...(mainTab === i ? style.labelFocus : {}),
											display: "inline-block",
										},
										onpointerdown: [ontabSelect, i],
									},
									hyperapp_text(x),
								),
							),
						),
					),
					h(
						"div",
						{
							style: {
								...style.tab,
								overflow: "auto",
								boxSizing: "border-box",
							},
						},
						Function_pipe(
							tabs,
							Array_get(mainTab),
							match({ onNone: () => {}, onSome: x => x() }),
						),
					),
				]),
			defaultText = {
				setting: ["Settings", "設定", "设置"],
				font: ["Font", "フォント", "字体"],
				color: ["Color(Normal)", "色(通常)", "颜色(正常)"],
				ownerColor: ["Color(Owner)", "色(オーナー)", "颜色(主人)"],
				moderatorColor: [
					"Color(Moderator)",
					"色(モデレーター)",
					"颜色(管理员)",
				],
				memberColor: ["Color(Member)", "色(メンバー)", "颜色(成员)"],
				feedback: ["Feedback", "バグ報告と要望", "反馈"],
				eventLog: ["Event log", "イベントログ", "事件日志"],
				giveFeedback: [
					"Give your feedbacks here(Please attach the event log for bug reports)",
					"バグ報告、要望はこちら(バグの場合は、イベントログを添付してください)",
					"在此处提供您的反馈(如报告错误,请附上事件日志)",
				],
				chatOpacity: ["Opacity", "不透明度", "不透明度"],
				fontSize: ["Size", "サイズ", "字体大小"],
				fontWeight: ["Weight", "太さ", "字体粗细"],
				shadowFontWeight: ["Shadow Weight", "影の太さ", "阴影粗细"],
				flowSpeed: ["Speed", "速度", "弹幕速度"],
				maxChatCount: ["Max number of chats", "最大表示数", "最大聊天数量"],
				maxChatLength: ["Max number of characters", "最大文字数", "最大字符数"],
				laneCount: ["Number of rows", "行数", "行数"],
				bannedWords: ["Banned Words", "NGワード", "屏蔽词"],
				bannedWordRegexes: [
					"Banned Words(Regex)",
					"NGワード(正規表現)",
					"屏蔽词(正则表达式)",
				],
				bannedUsers: ["Banned Users", "NGユーザー", "屏蔽用户"],
				simplifyChatField: ["Simplify", "簡略化する", "简化聊天栏"],
				createBanButton: [
					"Show ban button",
					"NGボタンを表示する",
					"显示屏蔽按钮",
				],
				displayModName: [
					"Show moderator's name",
					"モデレーターの名前を表示する",
					"显示管理员姓名",
				],
				displaySuperChatAuthor: [
					"Show super chat author",
					"スパチャの作成者を表示する",
					"显示超级留言作者",
				],
				createChats: ["Create flowing chats", "チャットを流す", "创建弹幕"],
				textOnly: [
					"Text only(ignore emojis)",
					"文字のみ(絵文字を無視する)",
					"仅文本(忽略表情符号)",
				],
				error: ["Error", "エラー", "错误"],
				video: ["Video", "画面", "视频"],
				chatField: ["Chat Window", "チャット欄", "聊天窗口"],
				useStepTiming: [
					"Move chat in steps",
					"チャットを段階的に動かす",
					"按步骤移动弹幕",
				],
				timingStepCount: ["└Step Count", "└段階数", "└步骤数"],
				chatFilter: ["Chat Filter", "チャットフィルター", "聊天过滤器"],
				flowChat: ["Flow Chat", "チャット流れ", "聊天弹幕"],
				clearFlowChats: [
					"Clear Flowing Chats",
					"流れるチャットをクリアする",
					"清除弹幕",
				],
				flowNewChatIf: [
					"A new chat will appear if all of the followings are met:",
					"新しいチャットは以下のすべてを満たす場合に流れます:",
					"如果满足以下所有条件,新弹幕会出现:",
				],
				noOverlap: [
					"└Chats won't overlap",
					"└他のチャットと重ならない",
					"└弹幕不会重叠",
				],
				minSpacing: [
					"Min spacing between chats",
					"チャットの最小間隔",
					"弹幕间的最小间距",
				],
				fieldScale: ["Scale", "拡大率", "缩放比例"],
				copy: ["Copy", "コピーする", "复制"],
				showChats: ["Show chats", "チャットを表示する", "显示弹幕"],
				hideChats: ["Hide chats", "チャットを非表示にする", "隐藏弹幕"],
				flowY1: ["Flow area top edge", "流れ範囲の上端", "显示区域上边缘"],
				flowY2: ["Flow area bottom edge", "流れ範囲の下端", "显示区域下边缘"],
				flowX1: ["Flow area left edge", "流れ範囲の左端", "显示区域左边缘"],
				flowX2: ["Flow area right edge", "流れ範囲の右端", "显示区域右边缘"],
				shadowColor: ["Shadow Color", "影の色", "阴影颜色"],
				invalidColor: ["Invalid color", "無効な色", "无效颜色"],
				inputNonNumberic: [
					"Input isn't a number",
					"入力値が数字でない",
					"输入值非数字",
				],
				invalidSetting: ["Invalid setting", "無効な設定値", "无效的设置值"],
				logEvents: [
					"Enable event logging",
					"イベントログを有効にする",
					"启用事件日志",
				],
				importLog: [
					"Import event log",
					"イベントログを取り込む",
					"导入事件日志",
				],
			},
			getText = key => state =>
				Function_pipe(
					languages,
					findFirstIndex(x => x === state.lang),
					map(x => Array_unsafeGet(defaultText[key], x)),
					getOrElse(() => "Error"),
				),
			languageLabels = ["English(US)", "日本語", "简体中文"],
			panelBoxStyle = width => ({
				flex: `0 0 ${width}px`,
				width: `${width}px`,
				margin: "2px",
			}),
			computed = {
				useStepTiming: s => isTruthy(s.timingFunction.match(/^steps\(.+/)),
			},
			getState = k => (k in computed ? computed[k] : s => s[k]),
			Data_Error = (function () {
				return class extends YieldableError {
					constructor(args) {
						super(args?.message, args?.cause ? { cause: args.cause } : void 0)
						args && Object.assign(this, args)
					}
				}
			})(),
			Data_TaggedError = tag => {
				class Base extends Data_Error {
					_tag = tag
				}
				Base.prototype.name = tag
				return Base
			},
			getKeysForIndexSignature = (input, parameter) => {
				switch (parameter._tag) {
					case "StringKeyword":
					case "TemplateLiteral":
						return Object.keys(input)
					case "SymbolKeyword":
						return Object.getOwnPropertySymbols(input)
					case "Refinement":
						return getKeysForIndexSignature(input, parameter.from)
				}
			},
			util_ownKeys = o =>
				Object.keys(o).concat(Object.getOwnPropertySymbols(o)),
			memoizeThunk = f => {
				let a,
					done = !1
				return () => {
					if (done) return a
					a = f()
					done = !0
					return a
				}
			},
			formatUnknown = u => {
				if (isString(u)) return JSON.stringify(u)
				if (
					isNumber(u) ||
					null == u ||
					Predicate_isBoolean(u) ||
					isSymbol(u) ||
					u instanceof Date
				)
					return String(u)
				if (isBigInt(u)) return String(u) + "n"
				if (
					!isArray(u) &&
					Predicate_hasProperty(u, "toString") &&
					Predicate_isFunction(u.toString) &&
					u.toString !== Object.prototype.toString
				)
					return u.toString()
				try {
					JSON.stringify(u)
					return isArray(u)
						? `[${u.map(formatUnknown).join(",")}]`
						: `{${util_ownKeys(u)
								.map(
									k =>
										`${isString(k) ? JSON.stringify(k) : String(k)}:${formatUnknown(u[k])}`,
								)
								.join(",")}}`
				} catch (e) {
					return String(u)
				}
			},
			util_isNonEmpty = x => Array.isArray(x),
			formatPathKey = key => {
				return `[${((name = key), "string" == typeof name ? JSON.stringify(name) : String(name))}]`
				var name
			},
			formatPath = path =>
				util_isNonEmpty(path)
					? path.map(formatPathKey).join("")
					: formatPathKey(path),
			getErrorMessage = (reason, details, path, ast) => {
				let out = reason
				path &&
					isNonEmptyReadonlyArray(path) &&
					(out += `\nat path: ${formatPath(path)}`)
				void 0 !== details && (out += `\ndetails: ${details}`)
				ast && (out += `\nschema (${ast._tag}): ${ast}`)
				return out
			},
			getASTDuplicateIndexSignatureErrorMessage = type =>
				getErrorMessage("Duplicate index signature", `${type} index signature`),
			getASTIndexSignatureParameterErrorMessage = getErrorMessage(
				"Unsupported index signature parameter",
				"An index signature parameter type must be `string`, `symbol`, a template literal type or a refinement of the previous types",
			),
			getASTRequiredElementFollowinAnOptionalElementErrorMessage =
				getErrorMessage(
					"Invalid element",
					"A required element cannot follow an optional element. ts(1257)",
				),
			TypeAnnotationId = Symbol.for("@effect/schema/annotation/Type"),
			MessageAnnotationId = Symbol.for("@effect/schema/annotation/Message"),
			MissingMessageAnnotationId = Symbol.for(
				"@effect/schema/annotation/MissingMessage",
			),
			IdentifierAnnotationId = Symbol.for(
				"@effect/schema/annotation/Identifier",
			),
			TitleAnnotationId = Symbol.for("@effect/schema/annotation/Title"),
			DescriptionAnnotationId = Symbol.for(
				"@effect/schema/annotation/Description",
			),
			ExamplesAnnotationId = Symbol.for("@effect/schema/annotation/Examples"),
			DefaultAnnotationId = Symbol.for("@effect/schema/annotation/Default"),
			JSONSchemaAnnotationId = Symbol.for(
				"@effect/schema/annotation/JSONSchema",
			),
			DocumentationAnnotationId = Symbol.for(
				"@effect/schema/annotation/Documentation",
			),
			ConcurrencyAnnotationId = Symbol.for(
				"@effect/schema/annotation/Concurrency",
			),
			BatchingAnnotationId = Symbol.for("@effect/schema/annotation/Batching"),
			ParseIssueTitleAnnotationId = Symbol.for(
				"@effect/schema/annotation/ParseIssueTitle",
			),
			ParseOptionsAnnotationId = Symbol.for(
				"@effect/schema/annotation/ParseOptions",
			),
			SurrogateAnnotationId = Symbol.for("@effect/schema/annotation/Surrogate"),
			StableFilterAnnotationId = Symbol.for(
				"@effect/schema/annotation/StableFilter",
			),
			getAnnotation = Function_dual(2, (annotated, key) =>
				Object.prototype.hasOwnProperty.call(annotated.annotations, key)
					? Option_some(annotated.annotations[key])
					: Option_none(),
			),
			getMessageAnnotation = getAnnotation(MessageAnnotationId),
			getMissingMessageAnnotation = getAnnotation(MissingMessageAnnotationId),
			getTitleAnnotation = getAnnotation(TitleAnnotationId),
			getIdentifierAnnotation = getAnnotation(IdentifierAnnotationId),
			getDescriptionAnnotation = getAnnotation(DescriptionAnnotationId),
			getConcurrencyAnnotation = getAnnotation(ConcurrencyAnnotationId),
			getBatchingAnnotation = getAnnotation(BatchingAnnotationId),
			getParseIssueTitleAnnotation = getAnnotation(ParseIssueTitleAnnotationId),
			getParseOptionsAnnotation = getAnnotation(ParseOptionsAnnotationId),
			getSurrogateAnnotation = getAnnotation(SurrogateAnnotationId),
			getStableFilterAnnotation = getAnnotation(StableFilterAnnotationId),
			JSONIdentifierAnnotationId = Symbol.for(
				"@effect/schema/annotation/JSONIdentifier",
			),
			getJSONIdentifierAnnotation = getAnnotation(JSONIdentifierAnnotationId)
		class Declaration {
			typeParameters
			decodeUnknown
			encodeUnknown
			annotations
			_tag = "Declaration"
			constructor(
				typeParameters,
				decodeUnknown,
				encodeUnknown,
				annotations = {},
			) {
				this.typeParameters = typeParameters
				this.decodeUnknown = decodeUnknown
				this.encodeUnknown = encodeUnknown
				this.annotations = annotations
			}
			toString() {
				return getOrElse(getExpected(this), () => "<declaration schema>")
			}
			toJSON() {
				return {
					_tag: this._tag,
					typeParameters: this.typeParameters.map(ast => ast.toJSON()),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const createASTGuard = tag => ast => ast._tag === tag
		class Literal {
			literal
			annotations
			_tag = "Literal"
			constructor(literal, annotations = {}) {
				this.literal = literal
				this.annotations = annotations
			}
			toString() {
				return getOrElse(getExpected(this), () => formatUnknown(this.literal))
			}
			toJSON() {
				return {
					_tag: this._tag,
					literal: isBigInt(this.literal) ? String(this.literal) : this.literal,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const isLiteral = createASTGuard("Literal")
		class UniqueSymbol {
			symbol
			annotations
			_tag = "UniqueSymbol"
			constructor(symbol, annotations = {}) {
				this.symbol = symbol
				this.annotations = annotations
			}
			toString() {
				return getOrElse(getExpected(this), () => formatUnknown(this.symbol))
			}
			toJSON() {
				return {
					_tag: this._tag,
					symbol: String(this.symbol),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		class NeverKeyword {
			annotations
			_tag = "NeverKeyword"
			constructor(annotations = {}) {
				this.annotations = annotations
			}
			toString() {
				return formatKeyword(this)
			}
			toJSON() {
				return {
					_tag: this._tag,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const neverKeyword = new NeverKeyword({ [TitleAnnotationId]: "never" })
		class UnknownKeyword {
			annotations
			_tag = "UnknownKeyword"
			constructor(annotations = {}) {
				this.annotations = annotations
			}
			toString() {
				return formatKeyword(this)
			}
			toJSON() {
				return {
					_tag: this._tag,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const unknownKeyword = new UnknownKeyword({
			[TitleAnnotationId]: "unknown",
		})
		class AnyKeyword {
			annotations
			_tag = "AnyKeyword"
			constructor(annotations = {}) {
				this.annotations = annotations
			}
			toString() {
				return formatKeyword(this)
			}
			toJSON() {
				return {
					_tag: this._tag,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const anyKeyword = new AnyKeyword({ [TitleAnnotationId]: "any" }),
			isStringKeyword = createASTGuard("StringKeyword"),
			isNumberKeyword = createASTGuard("NumberKeyword"),
			isSymbolKeyword = createASTGuard("SymbolKeyword")
		class Type {
			type
			annotations
			constructor(type, annotations = {}) {
				this.type = type
				this.annotations = annotations
			}
			toJSON() {
				return {
					type: this.type.toJSON(),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
			toString() {
				return String(this.type)
			}
		}
		class OptionalType extends Type {
			isOptional
			constructor(type, isOptional, annotations = {}) {
				super(type, annotations)
				this.isOptional = isOptional
			}
			toJSON() {
				return {
					type: this.type.toJSON(),
					isOptional: this.isOptional,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
			toString() {
				return String(this.type) + (this.isOptional ? "?" : "")
			}
		}
		const getRestASTs = rest => rest.map(annotatedAST => annotatedAST.type)
		class TupleType {
			elements
			rest
			isReadonly
			annotations
			_tag = "TupleType"
			constructor(elements, rest, isReadonly, annotations = {}) {
				this.elements = elements
				this.rest = rest
				this.isReadonly = isReadonly
				this.annotations = annotations
				let hasOptionalElement = !1,
					hasIllegalRequiredElement = !1
				for (const e of elements)
					if (e.isOptional) hasOptionalElement = !0
					else if (hasOptionalElement) {
						hasIllegalRequiredElement = !0
						break
					}
				if (
					hasIllegalRequiredElement ||
					(hasOptionalElement && rest.length > 1)
				)
					throw new Error(
						getASTRequiredElementFollowinAnOptionalElementErrorMessage,
					)
			}
			toString() {
				return getOrElse(getExpected(this), () => formatTuple(this))
			}
			toJSON() {
				return {
					_tag: this._tag,
					elements: this.elements.map(e => e.toJSON()),
					rest: this.rest.map(ast => ast.toJSON()),
					isReadonly: this.isReadonly,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const formatTuple = ast => {
			const formattedElements = ast.elements.map(String).join(", ")
			return matchLeft(ast.rest, {
				onEmpty: () => `readonly [${formattedElements}]`,
				onNonEmpty: (head, tail) => {
					const formattedHead = String(head),
						wrappedHead = formattedHead.includes(" | ")
							? `(${formattedHead})`
							: formattedHead
					if (tail.length > 0) {
						const formattedTail = tail.map(String).join(", ")
						return ast.elements.length > 0
							? `readonly [${formattedElements}, ...${wrappedHead}[], ${formattedTail}]`
							: `readonly [...${wrappedHead}[], ${formattedTail}]`
					}
					return ast.elements.length > 0
						? `readonly [${formattedElements}, ...${wrappedHead}[]]`
						: `ReadonlyArray<${formattedHead}>`
				},
			})
		}
		class PropertySignature extends OptionalType {
			name
			isReadonly
			constructor(name, type, isOptional, isReadonly, annotations) {
				super(type, isOptional, annotations)
				this.name = name
				this.isReadonly = isReadonly
			}
			toString() {
				return (
					(this.isReadonly ? "readonly " : "") +
					String(this.name) +
					(this.isOptional ? "?" : "") +
					": " +
					this.type
				)
			}
			toJSON() {
				return {
					name: String(this.name),
					type: this.type.toJSON(),
					isOptional: this.isOptional,
					isReadonly: this.isReadonly,
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const isParameter = ast => {
			switch (ast._tag) {
				case "StringKeyword":
				case "SymbolKeyword":
				case "TemplateLiteral":
					return !0
				case "Refinement":
					return isParameter(ast.from)
			}
			return !1
		}
		class IndexSignature {
			type
			isReadonly
			parameter
			constructor(parameter, type, isReadonly) {
				this.type = type
				this.isReadonly = isReadonly
				if (!isParameter(parameter))
					throw new Error(getASTIndexSignatureParameterErrorMessage)
				this.parameter = parameter
			}
			toString() {
				return (
					(this.isReadonly ? "readonly " : "") +
					`[x: ${this.parameter}]: ${this.type}`
				)
			}
			toJSON() {
				return {
					parameter: this.parameter.toJSON(),
					type: this.type.toJSON(),
					isReadonly: this.isReadonly,
				}
			}
		}
		class TypeLiteral {
			annotations
			_tag = "TypeLiteral"
			propertySignatures
			indexSignatures
			constructor(propertySignatures, indexSignatures, annotations = {}) {
				this.annotations = annotations
				const keys = {}
				for (let i = 0; i < propertySignatures.length; i++) {
					const name = propertySignatures[i].name
					if (Object.prototype.hasOwnProperty.call(keys, name))
						throw new Error(
							getErrorMessage(
								"Duplicate property signature",
								`Duplicate key ${formatUnknown(name)}`,
							),
						)
					keys[name] = null
				}
				const parameters = { string: !1, symbol: !1 }
				for (let i = 0; i < indexSignatures.length; i++) {
					const parameter = getParameterBase(indexSignatures[i].parameter)
					if (isStringKeyword(parameter)) {
						if (parameters.string)
							throw new Error(
								getASTDuplicateIndexSignatureErrorMessage("string"),
							)
						parameters.string = !0
					} else if (isSymbolKeyword(parameter)) {
						if (parameters.symbol)
							throw new Error(
								getASTDuplicateIndexSignatureErrorMessage("symbol"),
							)
						parameters.symbol = !0
					}
				}
				this.propertySignatures = sortPropertySignatures(propertySignatures)
				this.indexSignatures = sortIndexSignatures(indexSignatures)
			}
			toString() {
				return getOrElse(getExpected(this), () => formatTypeLiteral(this))
			}
			toJSON() {
				return {
					_tag: this._tag,
					propertySignatures: this.propertySignatures.map(ps => ps.toJSON()),
					indexSignatures: this.indexSignatures.map(ps => ps.toJSON()),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const formatIndexSignatures = iss => iss.map(String).join("; "),
			formatTypeLiteral = ast => {
				if (ast.propertySignatures.length > 0) {
					const pss = ast.propertySignatures.map(String).join("; ")
					return ast.indexSignatures.length > 0
						? `{ ${pss}; ${formatIndexSignatures(ast.indexSignatures)} }`
						: `{ ${pss} }`
				}
				return ast.indexSignatures.length > 0
					? `{ ${formatIndexSignatures(ast.indexSignatures)} }`
					: "{}"
			},
			sortCandidates = sort(
				Order_mapInput(Number_Order, ast => {
					switch (ast._tag) {
						case "AnyKeyword":
							return 0
						case "UnknownKeyword":
							return 1
						case "ObjectKeyword":
							return 2
						case "StringKeyword":
						case "NumberKeyword":
						case "BooleanKeyword":
						case "BigIntKeyword":
						case "SymbolKeyword":
							return 3
					}
					return 4
				}),
			),
			literalMap = {
				string: "StringKeyword",
				number: "NumberKeyword",
				boolean: "BooleanKeyword",
				bigint: "BigIntKeyword",
			},
			AST_flatten = candidates =>
				Array_flatMap(candidates, ast =>
					isUnion(ast) ? AST_flatten(ast.types) : [ast],
				)
		class Union {
			types
			annotations
			static make = (candidates, annotations) => {
				const types = [],
					memo = new Set()
				for (let i = 0; i < candidates.length; i++) {
					const ast = candidates[i]
					if (ast !== neverKeyword && !memo.has(ast)) {
						memo.add(ast)
						types.push(ast)
					}
				}
				return Union.union(types, annotations)
			}
			static members = (candidates, annotations) =>
				Union.union(
					(candidates => candidates.filter(ast => !(ast === neverKeyword)))(
						candidates,
					),
					annotations,
				)
			static unify = (candidates, annotations) =>
				Union.union(
					(candidates => {
						const cs = sortCandidates(candidates),
							out = [],
							uniques = {},
							literals = []
						for (const ast of cs)
							switch (ast._tag) {
								case "NeverKeyword":
									break
								case "AnyKeyword":
									return [anyKeyword]
								case "UnknownKeyword":
									return [unknownKeyword]
								case "ObjectKeyword":
								case "UndefinedKeyword":
								case "VoidKeyword":
								case "StringKeyword":
								case "NumberKeyword":
								case "BooleanKeyword":
								case "BigIntKeyword":
								case "SymbolKeyword":
									if (!uniques[ast._tag]) {
										uniques[ast._tag] = ast
										out.push(ast)
									}
									break
								case "Literal": {
									const type = typeof ast.literal
									switch (type) {
										case "string":
										case "number":
										case "bigint":
										case "boolean":
											if (
												!uniques[literalMap[type]] &&
												!literals.includes(ast.literal)
											) {
												literals.push(ast.literal)
												out.push(ast)
											}
											break
										case "object":
											if (!literals.includes(ast.literal)) {
												literals.push(ast.literal)
												out.push(ast)
											}
									}
									break
								}
								case "UniqueSymbol":
									if (
										!uniques.SymbolKeyword &&
										!literals.includes(ast.symbol)
									) {
										literals.push(ast.symbol)
										out.push(ast)
									}
									break
								case "TupleType":
									uniques.ObjectKeyword || out.push(ast)
									break
								case "TypeLiteral":
									if (
										0 === ast.propertySignatures.length &&
										0 === ast.indexSignatures.length
									) {
										if (!uniques["{}"]) {
											uniques["{}"] = ast
											out.push(ast)
										}
									} else uniques.ObjectKeyword || out.push(ast)
									break
								default:
									out.push(ast)
							}
						return out
					})(AST_flatten(candidates)),
					annotations,
				)
			static union = (types, annotations) =>
				isMembers(types)
					? new Union(types, annotations)
					: 1 === types.length
						? types[0]
						: neverKeyword
			_tag = "Union"
			constructor(types, annotations = {}) {
				this.types = types
				this.annotations = annotations
			}
			toString() {
				return getOrElse(getExpected(this), () =>
					this.types.map(String).join(" | "),
				)
			}
			toJSON() {
				return {
					_tag: this._tag,
					types: this.types.map(ast => ast.toJSON()),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const isMembers = as => as.length > 1,
			isUnion = createASTGuard("Union"),
			toJSONMemoMap = globalValue(
				Symbol.for("@effect/schema/AST/toJSONMemoMap"),
				() => new WeakMap(),
			)
		class Suspend {
			f
			annotations
			_tag = "Suspend"
			constructor(f, annotations = {}) {
				this.f = f
				this.annotations = annotations
				this.f = memoizeThunk(f)
			}
			toString() {
				return getExpected(this).pipe(
					orElse(() => {
						return flatMap(
							((f = this.f),
							(...a) => {
								try {
									return Option_some(f(...a))
								} catch (e) {
									return Option_none()
								}
							})(),
							ast => getExpected(ast),
						)
						var f
					}),
					getOrElse(() => "<suspended schema>"),
				)
			}
			toJSON() {
				const ast = this.f()
				let out = toJSONMemoMap.get(ast)
				if (out) return out
				toJSONMemoMap.set(ast, { _tag: this._tag })
				out = {
					_tag: this._tag,
					ast: ast.toJSON(),
					annotations: toJSONAnnotations(this.annotations),
				}
				toJSONMemoMap.set(ast, out)
				return out
			}
		}
		class Refinement {
			from
			filter
			annotations
			_tag = "Refinement"
			constructor(from, filter, annotations = {}) {
				this.from = from
				this.filter = filter
				this.annotations = annotations
			}
			toString() {
				return getOrElse(getExpected(this), () => `{ ${this.from} | filter }`)
			}
			toJSON() {
				return {
					_tag: this._tag,
					from: this.from.toJSON(),
					annotations: toJSONAnnotations(this.annotations),
				}
			}
		}
		const isRefinement = createASTGuard("Refinement"),
			defaultParseOption = {},
			isTransformation = createASTGuard("Transformation"),
			AST_annotations = (ast, annotations) => {
				const d = Object.getOwnPropertyDescriptors(ast)
				d.annotations.value = { ...ast.annotations, ...annotations }
				return Object.create(Object.getPrototypeOf(ast), d)
			},
			typeAST = ast => {
				switch (ast._tag) {
					case "Declaration": {
						const typeParameters = changeMap(ast.typeParameters, typeAST)
						return typeParameters === ast.typeParameters
							? ast
							: new Declaration(
									typeParameters,
									ast.decodeUnknown,
									ast.encodeUnknown,
									ast.annotations,
								)
					}
					case "TupleType": {
						const elements = changeMap(ast.elements, e => {
								const type = typeAST(e.type)
								return type === e.type
									? e
									: new OptionalType(type, e.isOptional)
							}),
							restASTs = getRestASTs(ast.rest),
							rest = changeMap(restASTs, typeAST)
						return elements === ast.elements && rest === restASTs
							? ast
							: new TupleType(
									elements,
									rest.map(type => new Type(type)),
									ast.isReadonly,
									ast.annotations,
								)
					}
					case "TypeLiteral": {
						const propertySignatures = changeMap(ast.propertySignatures, p => {
								const type = typeAST(p.type)
								return type === p.type
									? p
									: new PropertySignature(
											p.name,
											type,
											p.isOptional,
											p.isReadonly,
										)
							}),
							indexSignatures = changeMap(ast.indexSignatures, is => {
								const type = typeAST(is.type)
								return type === is.type
									? is
									: new IndexSignature(is.parameter, type, is.isReadonly)
							})
						return propertySignatures === ast.propertySignatures &&
							indexSignatures === ast.indexSignatures
							? ast
							: new TypeLiteral(
									propertySignatures,
									indexSignatures,
									ast.annotations,
								)
					}
					case "Union": {
						const types = changeMap(ast.types, typeAST)
						return types === ast.types
							? ast
							: Union.make(types, ast.annotations)
					}
					case "Suspend":
						return new Suspend(() => typeAST(ast.f()), ast.annotations)
					case "Refinement": {
						const from = typeAST(ast.from)
						return from === ast.from
							? ast
							: new Refinement(from, ast.filter, ast.annotations)
					}
					case "Transformation":
						return typeAST(ast.to)
				}
				return ast
			},
			createJSONIdentifierAnnotation = annotated =>
				match(
					(annotated =>
						orElse(getJSONIdentifierAnnotation(annotated), () =>
							getIdentifierAnnotation(annotated),
						))(annotated),
					{
						onNone: () => {},
						onSome: identifier => ({
							[JSONIdentifierAnnotationId]: identifier,
						}),
					},
				)
		function changeMap(as, f) {
			let changed = !1
			const out = allocate(as.length)
			for (let i = 0; i < as.length; i++) {
				const a = as[i],
					fa = f(a)
				fa !== a && (changed = !0)
				out[i] = fa
			}
			return changed ? out : as
		}
		const encodedAST_ = (ast, isBound) => {
				switch (ast._tag) {
					case "Declaration": {
						const typeParameters = changeMap(ast.typeParameters, ast =>
							encodedAST_(ast, isBound),
						)
						return typeParameters === ast.typeParameters
							? ast
							: new Declaration(
									typeParameters,
									ast.decodeUnknown,
									ast.encodeUnknown,
									ast.annotations,
								)
					}
					case "TupleType": {
						const elements = changeMap(ast.elements, e => {
								const type = encodedAST_(e.type, isBound)
								return type === e.type
									? e
									: new OptionalType(type, e.isOptional)
							}),
							restASTs = getRestASTs(ast.rest),
							rest = changeMap(restASTs, ast => encodedAST_(ast, isBound))
						return elements === ast.elements && rest === restASTs
							? ast
							: new TupleType(
									elements,
									rest.map(ast => new Type(ast)),
									ast.isReadonly,
									createJSONIdentifierAnnotation(ast),
								)
					}
					case "TypeLiteral": {
						const propertySignatures = changeMap(ast.propertySignatures, ps => {
								const type = encodedAST_(ps.type, isBound)
								return type === ps.type
									? ps
									: new PropertySignature(
											ps.name,
											type,
											ps.isOptional,
											ps.isReadonly,
										)
							}),
							indexSignatures = changeMap(ast.indexSignatures, is => {
								const type = encodedAST_(is.type, isBound)
								return type === is.type
									? is
									: new IndexSignature(is.parameter, type, is.isReadonly)
							})
						return propertySignatures === ast.propertySignatures &&
							indexSignatures === ast.indexSignatures
							? ast
							: new TypeLiteral(
									propertySignatures,
									indexSignatures,
									createJSONIdentifierAnnotation(ast),
								)
					}
					case "Union": {
						const types = changeMap(ast.types, ast => encodedAST_(ast, isBound))
						return types === ast.types
							? ast
							: Union.make(types, createJSONIdentifierAnnotation(ast))
					}
					case "Suspend":
						return new Suspend(
							() => encodedAST_(ast.f(), isBound),
							createJSONIdentifierAnnotation(ast),
						)
					case "Refinement": {
						const from = encodedAST_(ast.from, isBound)
						if (isBound) {
							if (from === ast.from) return ast
							if (!isTransformation(ast.from)) {
								const annotations = getStableFilterAnnotation(ast)
								if (Option_isSome(annotations) && !0 === annotations.value)
									return new Refinement(from, ast.filter)
							}
						}
						return from
					}
					case "Transformation":
						return encodedAST_(ast.from, isBound)
				}
				return ast
			},
			encodedAST = ast => encodedAST_(ast, !1),
			toJSONAnnotations = annotations => {
				const out = {}
				for (const k of Object.getOwnPropertySymbols(annotations))
					out[String(k)] = annotations[k]
				return out
			},
			sortPropertySignatures = sort(
				Order_mapInput(Number_Order, ps =>
					(ast => {
						switch (ast._tag) {
							case "NeverKeyword":
								return 0
							case "Literal":
							case "UndefinedKeyword":
							case "VoidKeyword":
							case "UniqueSymbol":
								return 1
							case "BooleanKeyword":
								return 2
							case "StringKeyword":
							case "NumberKeyword":
							case "BigIntKeyword":
							case "SymbolKeyword":
								return 3
							case "ObjectKeyword":
								return 5
							case "UnknownKeyword":
							case "AnyKeyword":
								return 6
							default:
								return 4
						}
					})(ps.type),
				),
			),
			sortIndexSignatures = sort(
				Order_mapInput(Number_Order, is => {
					switch (getParameterBase(is.parameter)._tag) {
						case "StringKeyword":
							return 2
						case "SymbolKeyword":
							return 3
						case "TemplateLiteral":
							return 1
					}
				}),
			),
			getParameterBase = ast => {
				switch (ast._tag) {
					case "StringKeyword":
					case "SymbolKeyword":
					case "TemplateLiteral":
						return ast
					case "Refinement":
						return getParameterBase(ast.from)
				}
			},
			formatKeyword = ast => getOrElse(getExpected(ast), () => ast._tag),
			getExpected = ast =>
				getIdentifierAnnotation(ast).pipe(
					orElse(() => getTitleAnnotation(ast)),
					orElse(() => getDescriptionAnnotation(ast)),
				),
			TreeFormatter_make = (value, forest = []) => ({ value, forest }),
			drawTree = tree => tree.value + draw("\n", tree.forest),
			draw = (indentation, forest) => {
				let r = ""
				const len = forest.length
				let tree
				for (let i = 0; i < len; i++) {
					tree = forest[i]
					const isLast = i === len - 1
					r += indentation + (isLast ? "└" : "├") + "─ " + tree.value
					r += draw(
						indentation + (len > 1 && !isLast ? "│  " : "   "),
						tree.forest,
					)
				}
				return r
			},
			formatTransformationKind = kind => {
				switch (kind) {
					case "Encoded":
						return "Encoded side transformation failure"
					case "Transformation":
						return "Transformation process failure"
					case "Type":
						return "Type side transformation failure"
				}
			},
			formatRefinementKind = kind => {
				switch (kind) {
					case "From":
						return "From side refinement failure"
					case "Predicate":
						return "Predicate refinement failure"
				}
			},
			getAnnotated = issue =>
				"ast" in issue ? Option_some(issue.ast) : Option_none(),
			createParseIssueGuard = tag => issue => issue._tag === tag,
			TreeFormatter_isComposite = createParseIssueGuard("Composite"),
			TreeFormatter_isRefinement = createParseIssueGuard("Refinement"),
			TreeFormatter_isTransformation = createParseIssueGuard("Transformation"),
			getMessage = issue =>
				(issue =>
					getAnnotated(issue).pipe(
						flatMap(getMessageAnnotation),
						Effect_flatMap(annotation => {
							const out = annotation(issue)
							return isString(out)
								? Effect_succeed({ message: out, override: !1 })
								: Effect_isEffect(out)
									? Effect_map(out, message => ({ message, override: !1 }))
									: isString(out.message)
										? Effect_succeed({
												message: out.message,
												override: out.override,
											})
										: Effect_map(out.message, message => ({
												message,
												override: out.override,
											}))
						}),
					))(issue).pipe(
					Effect_flatMap(currentMessage =>
						!currentMessage.override &&
						(TreeFormatter_isComposite(issue) ||
							(TreeFormatter_isRefinement(issue) && "From" === issue.kind) ||
							(TreeFormatter_isTransformation(issue) &&
								"Transformation" !== issue.kind))
							? TreeFormatter_isTransformation(issue) ||
								TreeFormatter_isRefinement(issue)
								? getMessage(issue.issue)
								: Option_none()
							: Effect_succeed(currentMessage.message),
					),
				),
			TreeFormatter_getParseIssueTitleAnnotation = issue =>
				getAnnotated(issue).pipe(
					flatMap(getParseIssueTitleAnnotation),
					filterMap(annotation => fromNullable(annotation(issue))),
				),
			getParseIssueTitle = issue =>
				getOrElse(TreeFormatter_getParseIssueTitleAnnotation(issue), () =>
					String(issue.ast),
				),
			formatForbiddenMessage = e => e.message ?? "is forbidden",
			getTree = (issue, onFailure) =>
				Effect_matchEffect(getMessage(issue), {
					onFailure,
					onSuccess: message => Effect_succeed(TreeFormatter_make(message)),
				}),
			go = e => {
				switch (e._tag) {
					case "Type":
						return Effect_map(
							(e =>
								getMessage(e).pipe(
									Effect_orElse(() =>
										TreeFormatter_getParseIssueTitleAnnotation(e),
									),
									Effect_catchAll(() =>
										Effect_succeed(
											e.message ??
												`Expected ${String(e.ast)}, actual ${formatUnknown(e.actual)}`,
										),
									),
								))(e),
							TreeFormatter_make,
						)
					case "Forbidden":
						return Effect_succeed(
							TreeFormatter_make(getParseIssueTitle(e), [
								TreeFormatter_make(formatForbiddenMessage(e)),
							]),
						)
					case "Unexpected":
						return Effect_succeed(
							TreeFormatter_make((e => e.message ?? "is unexpected")(e)),
						)
					case "Missing":
						return Effect_map(
							(e =>
								getMissingMessageAnnotation(e.ast).pipe(
									Effect_flatMap(annotation => {
										const out = annotation()
										return isString(out) ? Effect_succeed(out) : out
									}),
									Effect_catchAll(() =>
										Effect_succeed(e.message ?? "is missing"),
									),
								))(e),
							TreeFormatter_make,
						)
					case "Transformation":
						return getTree(e, () =>
							Effect_map(go(e.issue), tree =>
								TreeFormatter_make(getParseIssueTitle(e), [
									TreeFormatter_make(formatTransformationKind(e.kind), [tree]),
								]),
							),
						)
					case "Refinement":
						return getTree(e, () =>
							Effect_map(go(e.issue), tree =>
								TreeFormatter_make(getParseIssueTitle(e), [
									TreeFormatter_make(formatRefinementKind(e.kind), [tree]),
								]),
							),
						)
					case "Pointer":
						return Effect_map(go(e.issue), tree =>
							TreeFormatter_make(formatPath(e.path), [tree]),
						)
					case "Composite": {
						const parseIssueTitle = getParseIssueTitle(e)
						return getTree(e, () =>
							util_isNonEmpty(e.issues)
								? Effect_map(Effect_forEach(e.issues, go), forest =>
										TreeFormatter_make(parseIssueTitle, forest),
									)
								: Effect_map(go(e.issues), tree =>
										TreeFormatter_make(parseIssueTitle, [tree]),
									),
						)
					}
				}
			}
		class Pointer {
			path
			actual
			issue
			_tag = "Pointer"
			constructor(path, actual, issue) {
				this.path = path
				this.actual = actual
				this.issue = issue
			}
		}
		class Unexpected {
			actual
			message
			_tag = "Unexpected"
			constructor(actual, message) {
				this.actual = actual
				this.message = message
			}
		}
		class Missing {
			ast
			message
			_tag = "Missing"
			actual = void 0
			constructor(ast, message) {
				this.ast = ast
				this.message = message
			}
		}
		class ParseResult_Composite {
			ast
			actual
			issues
			output
			_tag = "Composite"
			constructor(ast, actual, issues, output) {
				this.ast = ast
				this.actual = actual
				this.issues = issues
				this.output = output
			}
		}
		class ParseResult_Refinement {
			ast
			actual
			kind
			issue
			_tag = "Refinement"
			constructor(ast, actual, kind, issue) {
				this.ast = ast
				this.actual = actual
				this.kind = kind
				this.issue = issue
			}
		}
		class ParseResult_Transformation {
			ast
			actual
			kind
			issue
			_tag = "Transformation"
			constructor(ast, actual, kind, issue) {
				this.ast = ast
				this.actual = actual
				this.kind = kind
				this.issue = issue
			}
		}
		class ParseResult_Type {
			ast
			actual
			message
			_tag = "Type"
			constructor(ast, actual, message) {
				this.ast = ast
				this.actual = actual
				this.message = message
			}
		}
		class Forbidden {
			ast
			actual
			message
			_tag = "Forbidden"
			constructor(ast, actual, message) {
				this.ast = ast
				this.actual = actual
				this.message = message
			}
		}
		const ParseResult_ParseErrorTypeId = Symbol.for(
			"@effect/schema/ParseErrorTypeId",
		)
		class ParseResult_ParseError extends Data_TaggedError("ParseError") {
			[ParseResult_ParseErrorTypeId] = ParseResult_ParseErrorTypeId
			get message() {
				return this.toString()
			}
			toString() {
				return (
					(issue = this.issue),
					Effect_runSync(
						(issue => Effect_map(go(issue), tree => drawTree(tree)))(issue),
					)
				)
				var issue
			}
			toJSON() {
				return { _id: "ParseError", message: this.toString() }
			}
			[Inspectable_NodeInspectSymbol]() {
				return this.toJSON()
			}
		}
		const parseError = issue => new ParseResult_ParseError({ issue }),
			ParseResult_succeed = Either_right,
			ParseResult_fail = Either_left,
			ParseResult_flatMap = Function_dual(2, (self, f) => {
				const s = self
				return "Left" === s._tag
					? s
					: "Right" === s._tag
						? f(s.right)
						: Effect_flatMap(self, f)
			}),
			ParseResult_map = Function_dual(2, (self, f) => {
				const s = self
				return "Left" === s._tag
					? s
					: "Right" === s._tag
						? Either_right(f(s.right))
						: Effect_map(self, f)
			}),
			ParseResult_mapError = Function_dual(2, (self, f) => {
				const s = self
				return "Left" === s._tag
					? Either_left(f(s.left))
					: "Right" === s._tag
						? s
						: Effect_mapError(self, f)
			}),
			eitherOrUndefined = self => {
				const s = self
				if ("Left" === s._tag || "Right" === s._tag) return s
			},
			mergeInternalOptions = (options, overrideOptions) =>
				void 0 === overrideOptions || isNumber(overrideOptions)
					? options
					: void 0 === options
						? overrideOptions
						: { ...options, ...overrideOptions },
			decodeUnknownSync = (schema, options) =>
				((ast, isDecoding, options) => {
					const parser = ((ast, isDecoding, options) => {
						const parser = goMemo(ast, isDecoding)
						return (u, overrideOptions) =>
							parser(u, mergeInternalOptions(options, overrideOptions))
					})(ast, isDecoding, options)
					return (input, overrideOptions) =>
						Either_getOrThrowWith(parser(input, overrideOptions), parseError)
				})(schema.ast, !0, options),
			decodeMemoMap = globalValue(
				Symbol.for("@effect/schema/Parser/decodeMemoMap"),
				() => new WeakMap(),
			),
			encodeMemoMap = globalValue(
				Symbol.for("@effect/schema/Parser/encodeMemoMap"),
				() => new WeakMap(),
			),
			goMemo = (ast, isDecoding) => {
				const memoMap = isDecoding ? decodeMemoMap : encodeMemoMap,
					memo = memoMap.get(ast)
				if (memo) return memo
				const raw = ParseResult_go(ast, isDecoding),
					parseOptionsAnnotation = getParseOptionsAnnotation(ast),
					parser = Option_isSome(parseOptionsAnnotation)
						? (i, options) =>
								raw(
									i,
									mergeInternalOptions(options, parseOptionsAnnotation.value),
								)
						: raw
				memoMap.set(ast, parser)
				return parser
			},
			getConcurrency = ast => getOrUndefined(getConcurrencyAnnotation(ast)),
			getBatching = ast => getOrUndefined(getBatchingAnnotation(ast)),
			ParseResult_go = (ast, isDecoding) => {
				switch (ast._tag) {
					case "Refinement":
						if (isDecoding) {
							const from = goMemo(ast.from, !0)
							return (i, options) =>
								handleForbidden(
									ParseResult_flatMap(
										ParseResult_mapError(
											from(i, options),
											e => new ParseResult_Refinement(ast, i, "From", e),
										),
										a =>
											match(ast.filter(a, options ?? defaultParseOption, ast), {
												onNone: () => Either_right(a),
												onSome: e =>
													Either_left(
														new ParseResult_Refinement(ast, i, "Predicate", e),
													),
											}),
									),
									ast,
									i,
									options,
								)
						}
						{
							const from = goMemo(typeAST(ast), !0),
								to = goMemo(dropRightRefinement(ast.from), !1)
							return (i, options) =>
								handleForbidden(
									ParseResult_flatMap(from(i, options), a => to(a, options)),
									ast,
									i,
									options,
								)
						}
					case "Transformation": {
						const transform = getFinalTransformation(
								ast.transformation,
								isDecoding,
							),
							from = isDecoding ? goMemo(ast.from, !0) : goMemo(ast.to, !1),
							to = isDecoding ? goMemo(ast.to, !0) : goMemo(ast.from, !1)
						return (i, options) =>
							handleForbidden(
								ParseResult_flatMap(
									ParseResult_mapError(
										from(i, options),
										e =>
											new ParseResult_Transformation(
												ast,
												i,
												isDecoding ? "Encoded" : "Type",
												e,
											),
									),
									a =>
										ParseResult_flatMap(
											ParseResult_mapError(
												transform(a, options ?? defaultParseOption, ast, i),
												e =>
													new ParseResult_Transformation(
														ast,
														i,
														"Transformation",
														e,
													),
											),
											i2 =>
												ParseResult_mapError(
													to(i2, options),
													e =>
														new ParseResult_Transformation(
															ast,
															i,
															isDecoding ? "Type" : "Encoded",
															e,
														),
												),
										),
								),
								ast,
								i,
								options,
							)
					}
					case "Declaration": {
						const parse = isDecoding
							? ast.decodeUnknown(...ast.typeParameters)
							: ast.encodeUnknown(...ast.typeParameters)
						return (i, options) =>
							handleForbidden(
								parse(i, options ?? defaultParseOption, ast),
								ast,
								i,
								options,
							)
					}
					case "Literal":
						return fromRefinement(ast, u => u === ast.literal)
					case "UniqueSymbol":
						return fromRefinement(ast, u => u === ast.symbol)
					case "UndefinedKeyword":
						return fromRefinement(ast, isUndefined)
					case "NeverKeyword":
						return fromRefinement(ast, isNever)
					case "UnknownKeyword":
					case "AnyKeyword":
					case "VoidKeyword":
						return Either_right
					case "StringKeyword":
						return fromRefinement(ast, isString)
					case "NumberKeyword":
						return fromRefinement(ast, isNumber)
					case "BooleanKeyword":
						return fromRefinement(ast, Predicate_isBoolean)
					case "BigIntKeyword":
						return fromRefinement(ast, isBigInt)
					case "SymbolKeyword":
						return fromRefinement(ast, isSymbol)
					case "ObjectKeyword":
						return fromRefinement(ast, Predicate_isObject)
					case "Enums":
						return fromRefinement(ast, u =>
							ast.enums.some(([_, value]) => value === u),
						)
					case "TemplateLiteral": {
						const regex = (ast => {
							let pattern = `^${RegExp_escape(ast.head)}`
							for (const span of ast.spans) {
								isStringKeyword(span.type)
									? (pattern += ".*")
									: isNumberKeyword(span.type) &&
										(pattern += "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?")
								pattern += RegExp_escape(span.literal)
							}
							pattern += "$"
							return new RegExp(pattern)
						})(ast)
						return fromRefinement(ast, u => isString(u) && regex.test(u))
					}
					case "TupleType": {
						const elements = ast.elements.map(e => goMemo(e.type, isDecoding)),
							rest = ast.rest.map(annotatedAST =>
								goMemo(annotatedAST.type, isDecoding),
							)
						let requiredTypes = ast.elements.filter(e => !e.isOptional)
						ast.rest.length > 0 &&
							(requiredTypes = requiredTypes.concat(ast.rest.slice(1)))
						const requiredLen = requiredTypes.length,
							expectedIndexes =
								ast.elements.length > 0
									? ast.elements.map((_, i) => i).join(" | ")
									: "never",
							concurrency = getConcurrency(ast),
							batching = getBatching(ast)
						return (input, options) => {
							if (!isArray(input))
								return Either_left(new ParseResult_Type(ast, input))
							const allErrors = "all" === options?.errors,
								es = []
							let stepKey = 0
							const output = [],
								len = input.length
							for (let i = len; i <= requiredLen - 1; i++) {
								const e = new Pointer(
									i,
									input,
									new Missing(requiredTypes[i - len]),
								)
								if (!allErrors)
									return Either_left(
										new ParseResult_Composite(ast, input, e, output),
									)
								es.push([stepKey++, e])
							}
							if (0 === ast.rest.length)
								for (let i = ast.elements.length; i <= len - 1; i++) {
									const e = new Pointer(
										i,
										input,
										new Unexpected(
											input[i],
											`is unexpected, expected: ${expectedIndexes}`,
										),
									)
									if (!allErrors)
										return Either_left(
											new ParseResult_Composite(ast, input, e, output),
										)
									es.push([stepKey++, e])
								}
							let queue,
								i = 0
							for (; i < elements.length; i++)
								if (len < i + 1) {
									if (ast.elements[i].isOptional) continue
								} else {
									const te = (0, elements[i])(input[i], options),
										eu = eitherOrUndefined(te)
									if (eu) {
										if (Either_isLeft(eu)) {
											const e = new Pointer(i, input, eu.left)
											if (allErrors) {
												es.push([stepKey++, e])
												continue
											}
											return Either_left(
												new ParseResult_Composite(
													ast,
													input,
													e,
													sortByIndex(output),
												),
											)
										}
										output.push([stepKey++, eu.right])
									} else {
										const nk = stepKey++,
											index = i
										queue || (queue = [])
										queue.push(({ es, output }) =>
											Effect_flatMap(Effect_either(te), t => {
												if (Either_isLeft(t)) {
													const e = new Pointer(index, input, t.left)
													if (allErrors) {
														es.push([nk, e])
														return _void
													}
													return Either_left(
														new ParseResult_Composite(
															ast,
															input,
															e,
															sortByIndex(output),
														),
													)
												}
												output.push([nk, t.right])
												return _void
											}),
										)
									}
								}
							if (isNonEmptyReadonlyArray(rest)) {
								const [head, ...tail] = rest
								for (; i < len - tail.length; i++) {
									const te = head(input[i], options),
										eu = eitherOrUndefined(te)
									if (eu) {
										if (Either_isLeft(eu)) {
											const e = new Pointer(i, input, eu.left)
											if (allErrors) {
												es.push([stepKey++, e])
												continue
											}
											return Either_left(
												new ParseResult_Composite(
													ast,
													input,
													e,
													sortByIndex(output),
												),
											)
										}
										output.push([stepKey++, eu.right])
									} else {
										const nk = stepKey++,
											index = i
										queue || (queue = [])
										queue.push(({ es, output }) =>
											Effect_flatMap(Effect_either(te), t => {
												if (Either_isLeft(t)) {
													const e = new Pointer(index, input, t.left)
													if (allErrors) {
														es.push([nk, e])
														return _void
													}
													return Either_left(
														new ParseResult_Composite(
															ast,
															input,
															e,
															sortByIndex(output),
														),
													)
												}
												output.push([nk, t.right])
												return _void
											}),
										)
									}
								}
								for (let j = 0; j < tail.length; j++) {
									i += j
									if (!(len < i + 1)) {
										const te = tail[j](input[i], options),
											eu = eitherOrUndefined(te)
										if (eu) {
											if (Either_isLeft(eu)) {
												const e = new Pointer(i, input, eu.left)
												if (allErrors) {
													es.push([stepKey++, e])
													continue
												}
												return Either_left(
													new ParseResult_Composite(
														ast,
														input,
														e,
														sortByIndex(output),
													),
												)
											}
											output.push([stepKey++, eu.right])
										} else {
											const nk = stepKey++,
												index = i
											queue || (queue = [])
											queue.push(({ es, output }) =>
												Effect_flatMap(Effect_either(te), t => {
													if (Either_isLeft(t)) {
														const e = new Pointer(index, input, t.left)
														if (allErrors) {
															es.push([nk, e])
															return _void
														}
														return Either_left(
															new ParseResult_Composite(
																ast,
																input,
																e,
																sortByIndex(output),
															),
														)
													}
													output.push([nk, t.right])
													return _void
												}),
											)
										}
									}
								}
							}
							const computeResult = ({ es, output }) =>
								Array_isNonEmptyArray(es)
									? Either_left(
											new ParseResult_Composite(
												ast,
												input,
												sortByIndex(es),
												sortByIndex(output),
											),
										)
									: Either_right(sortByIndex(output))
							if (queue && queue.length > 0) {
								const cqueue = queue
								return Effect_suspend(() => {
									const state = { es: copy(es), output: copy(output) }
									return Effect_flatMap(
										Effect_forEach(cqueue, f => f(state), {
											concurrency,
											batching,
											discard: !0,
										}),
										() => computeResult(state),
									)
								})
							}
							return computeResult({ output, es })
						}
					}
					case "TypeLiteral": {
						if (
							0 === ast.propertySignatures.length &&
							0 === ast.indexSignatures.length
						)
							return fromRefinement(ast, isNotNullable)
						const propertySignatures = [],
							expectedKeysMap = {},
							expectedKeys = []
						for (const ps of ast.propertySignatures) {
							propertySignatures.push([goMemo(ps.type, isDecoding), ps])
							expectedKeysMap[ps.name] = null
							expectedKeys.push(ps.name)
						}
						const indexSignatures = ast.indexSignatures.map(is => [
								goMemo(is.parameter, isDecoding),
								goMemo(is.type, isDecoding),
								is.parameter,
							]),
							expectedAST = Union.make(
								ast.indexSignatures
									.map(is => is.parameter)
									.concat(
										expectedKeys.map(key =>
											isSymbol(key) ? new UniqueSymbol(key) : new Literal(key),
										),
									),
							),
							expected = goMemo(expectedAST, isDecoding),
							concurrency = getConcurrency(ast),
							batching = getBatching(ast)
						return (input, options) => {
							if (!isRecord(input))
								return Either_left(new ParseResult_Type(ast, input))
							const allErrors = "all" === options?.errors,
								es = []
							let stepKey = 0
							const onExcessPropertyError =
									"error" === options?.onExcessProperty,
								output = {}
							let inputKeys, queue
							if (
								onExcessPropertyError ||
								"preserve" === options?.onExcessProperty
							) {
								inputKeys = util_ownKeys(input)
								for (const key of inputKeys) {
									const eu = eitherOrUndefined(expected(key, options))
									if (Either_isLeft(eu)) {
										if (onExcessPropertyError) {
											const e = new Pointer(
												key,
												input,
												new Unexpected(
													input[key],
													`is unexpected, expected: ${String(expectedAST)}`,
												),
											)
											if (allErrors) {
												es.push([stepKey++, e])
												continue
											}
											return Either_left(
												new ParseResult_Composite(ast, input, e, output),
											)
										}
										output[key] = input[key]
									}
								}
							}
							const isExact = !0 === options?.exact
							for (let i = 0; i < propertySignatures.length; i++) {
								const ps = propertySignatures[i][1],
									name = ps.name,
									hasKey = Object.prototype.hasOwnProperty.call(input, name)
								if (!hasKey) {
									if (ps.isOptional) continue
									if (isExact) {
										const e = new Pointer(name, input, new Missing(ps))
										if (allErrors) {
											es.push([stepKey++, e])
											continue
										}
										return Either_left(
											new ParseResult_Composite(ast, input, e, output),
										)
									}
								}
								const te = (0, propertySignatures[i][0])(input[name], options),
									eu = eitherOrUndefined(te)
								if (eu) {
									if (Either_isLeft(eu)) {
										const e = new Pointer(
											name,
											input,
											hasKey ? eu.left : new Missing(ps),
										)
										if (allErrors) {
											es.push([stepKey++, e])
											continue
										}
										return Either_left(
											new ParseResult_Composite(ast, input, e, output),
										)
									}
									output[name] = eu.right
								} else {
									const nk = stepKey++,
										index = name
									queue || (queue = [])
									queue.push(({ es, output }) =>
										Effect_flatMap(Effect_either(te), t => {
											if (Either_isLeft(t)) {
												const e = new Pointer(
													index,
													input,
													hasKey ? t.left : new Missing(ps),
												)
												if (allErrors) {
													es.push([nk, e])
													return _void
												}
												return Either_left(
													new ParseResult_Composite(ast, input, e, output),
												)
											}
											output[index] = t.right
											return _void
										}),
									)
								}
							}
							for (let i = 0; i < indexSignatures.length; i++) {
								const indexSignature = indexSignatures[i],
									parameter = indexSignature[0],
									type = indexSignature[1],
									keys = getKeysForIndexSignature(input, indexSignature[2])
								for (const key of keys) {
									const keu = eitherOrUndefined(parameter(key, options))
									if (keu && Either_isRight(keu)) {
										const vpr = type(input[key], options),
											veu = eitherOrUndefined(vpr)
										if (veu) {
											if (Either_isLeft(veu)) {
												const e = new Pointer(key, input, veu.left)
												if (allErrors) {
													es.push([stepKey++, e])
													continue
												}
												return Either_left(
													new ParseResult_Composite(ast, input, e, output),
												)
											}
											Object.prototype.hasOwnProperty.call(
												expectedKeysMap,
												key,
											) || (output[key] = veu.right)
										} else {
											const nk = stepKey++,
												index = key
											queue || (queue = [])
											queue.push(({ es, output }) =>
												Effect_flatMap(Effect_either(vpr), tv => {
													if (Either_isLeft(tv)) {
														const e = new Pointer(index, input, tv.left)
														if (allErrors) {
															es.push([nk, e])
															return _void
														}
														return Either_left(
															new ParseResult_Composite(ast, input, e, output),
														)
													}
													Object.prototype.hasOwnProperty.call(
														expectedKeysMap,
														key,
													) || (output[key] = tv.right)
													return _void
												}),
											)
										}
									}
								}
							}
							const computeResult = ({ es, output }) => {
								if (Array_isNonEmptyArray(es))
									return Either_left(
										new ParseResult_Composite(
											ast,
											input,
											sortByIndex(es),
											output,
										),
									)
								if ("original" === options?.propertyOrder) {
									const keys = inputKeys || util_ownKeys(input)
									for (const name of expectedKeys)
										-1 === keys.indexOf(name) && keys.push(name)
									const out = {}
									for (const key of keys)
										Object.prototype.hasOwnProperty.call(output, key) &&
											(out[key] = output[key])
									return Either_right(out)
								}
								return Either_right(output)
							}
							if (queue && queue.length > 0) {
								const cqueue = queue
								return Effect_suspend(() => {
									const state = {
										es: copy(es),
										output: Object.assign({}, output),
									}
									return Effect_flatMap(
										Effect_forEach(cqueue, f => f(state), {
											concurrency,
											batching,
											discard: !0,
										}),
										() => computeResult(state),
									)
								})
							}
							return computeResult({ es, output })
						}
					}
					case "Union": {
						const searchTree = getSearchTree(ast.types, isDecoding),
							ownKeys = util_ownKeys(searchTree.keys),
							len = ownKeys.length,
							map = new Map()
						for (let i = 0; i < ast.types.length; i++)
							map.set(ast.types[i], goMemo(ast.types[i], isDecoding))
						const concurrency = getConcurrency(ast) ?? 1,
							batching = getBatching(ast)
						return (input, options) => {
							const es = []
							let queue,
								stepKey = 0,
								candidates = []
							if (len > 0)
								if (isRecord(input))
									for (let i = 0; i < len; i++) {
										const name = ownKeys[i],
											buckets = searchTree.keys[name].buckets
										if (Object.prototype.hasOwnProperty.call(input, name)) {
											const literal = String(input[name])
											if (
												Object.prototype.hasOwnProperty.call(buckets, literal)
											)
												candidates = candidates.concat(buckets[literal])
											else {
												const literals = Union.make(
													searchTree.keys[name].literals,
												)
												es.push([
													stepKey++,
													new ParseResult_Composite(
														new TypeLiteral(
															[new PropertySignature(name, literals, !1, !0)],
															[],
														),
														input,
														new Pointer(
															name,
															input,
															new ParseResult_Type(literals, input[name]),
														),
													),
												])
											}
										} else {
											const literals = Union.make(
													searchTree.keys[name].literals,
												),
												fakeps = new PropertySignature(name, literals, !1, !0)
											es.push([
												stepKey++,
												new ParseResult_Composite(
													new TypeLiteral([fakeps], []),
													input,
													new Pointer(name, input, new Missing(fakeps)),
												),
											])
										}
									}
								else es.push([stepKey++, new ParseResult_Type(ast, input)])
							searchTree.otherwise.length > 0 &&
								(candidates = candidates.concat(searchTree.otherwise))
							for (let i = 0; i < candidates.length; i++) {
								const candidate = candidates[i],
									pr = map.get(candidate)(input, options),
									eu =
										queue && 0 !== queue.length ? void 0 : eitherOrUndefined(pr)
								if (eu) {
									if (Either_isRight(eu)) return Either_right(eu.right)
									es.push([stepKey++, eu.left])
								} else {
									const nk = stepKey++
									queue || (queue = [])
									queue.push(state =>
										Effect_suspend(() =>
											"finalResult" in state
												? _void
												: Effect_flatMap(Effect_either(pr), t => {
														Either_isRight(t)
															? (state.finalResult = Either_right(t.right))
															: state.es.push([nk, t.left])
														return _void
													}),
										),
									)
								}
							}
							const computeResult = es =>
								Array_isNonEmptyArray(es)
									? 1 === es.length && "Type" === es[0][1]._tag
										? Either_left(es[0][1])
										: Either_left(
												new ParseResult_Composite(ast, input, sortByIndex(es)),
											)
									: Either_left(new ParseResult_Type(ast, input))
							if (queue && queue.length > 0) {
								const cqueue = queue
								return Effect_suspend(() => {
									const state = { es: copy(es) }
									return Effect_flatMap(
										Effect_forEach(cqueue, f => f(state), {
											concurrency,
											batching,
											discard: !0,
										}),
										() =>
											"finalResult" in state
												? state.finalResult
												: computeResult(state.es),
									)
								})
							}
							return computeResult(es)
						}
					}
					case "Suspend": {
						const get = memoizeThunk(() =>
							goMemo(AST_annotations(ast.f(), ast.annotations), isDecoding),
						)
						return (a, options) => get()(a, options)
					}
				}
			},
			fromRefinement = (ast, refinement) => u =>
				refinement(u)
					? Either_right(u)
					: Either_left(new ParseResult_Type(ast, u)),
			getLiterals = (ast, isDecoding) => {
				switch (ast._tag) {
					case "Declaration": {
						const annotation = getSurrogateAnnotation(ast)
						if (Option_isSome(annotation))
							return getLiterals(annotation.value, isDecoding)
						break
					}
					case "TypeLiteral": {
						const out = []
						for (let i = 0; i < ast.propertySignatures.length; i++) {
							const propertySignature = ast.propertySignatures[i],
								type = isDecoding
									? encodedAST(propertySignature.type)
									: typeAST(propertySignature.type)
							isLiteral(type) &&
								!propertySignature.isOptional &&
								out.push([propertySignature.name, type])
						}
						return out
					}
					case "Refinement":
						return getLiterals(ast.from, isDecoding)
					case "Suspend":
						return getLiterals(ast.f(), isDecoding)
					case "Transformation":
						return getLiterals(isDecoding ? ast.from : ast.to, isDecoding)
				}
				return []
			},
			getSearchTree = (members, isDecoding) => {
				const keys = {},
					otherwise = []
				for (let i = 0; i < members.length; i++) {
					const member = members[i],
						tags = getLiterals(member, isDecoding)
					if (tags.length > 0)
						for (let j = 0; j < tags.length; j++) {
							const [key, literal] = tags[j],
								hash = String(literal.literal)
							keys[key] = keys[key] || { buckets: {}, literals: [] }
							const buckets = keys[key].buckets
							if (!Object.prototype.hasOwnProperty.call(buckets, hash)) {
								buckets[hash] = [member]
								keys[key].literals.push(literal)
								break
							}
							if (!(j < tags.length - 1)) {
								buckets[hash].push(member)
								keys[key].literals.push(literal)
							}
						}
					else otherwise.push(member)
				}
				return { keys, otherwise }
			},
			dropRightRefinement = ast =>
				isRefinement(ast) ? dropRightRefinement(ast.from) : ast,
			handleForbidden = (effect, ast, actual, options) => {
				const eu = eitherOrUndefined(effect)
				if (eu) return eu
				if (!0 === options?.isEffectAllowed) return effect
				try {
					return Effect_runSync(Effect_either(effect))
				} catch (e) {
					return Either_left(
						new Forbidden(
							ast,
							actual,
							"cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work",
						),
					)
				}
			},
			compare = ([a], [b]) => (a > b ? 1 : a < b ? -1 : 0)
		function sortByIndex(es) {
			return es.sort(compare).map(t => t[1])
		}
		const getFinalTransformation = (transformation, isDecoding) => {
				switch (transformation._tag) {
					case "FinalTransformation":
						return isDecoding ? transformation.decode : transformation.encode
					case "ComposeTransformation":
						return Either_right
					case "TypeLiteralTransformation":
						return input => {
							let out = Either_right(input)
							for (const pst of transformation.propertySignatureTransformations) {
								const [from, to] = isDecoding
										? [pst.from, pst.to]
										: [pst.to, pst.from],
									transformation = isDecoding ? pst.decode : pst.encode,
									f = input => {
										const o = transformation(
											Object.prototype.hasOwnProperty.call(input, from)
												? Option_some(input[from])
												: Option_none(),
										)
										delete input[from]
										Option_isSome(o) && (input[to] = o.value)
										return input
									}
								out = ParseResult_map(out, f)
							}
							return out
						}
				}
			},
			ArbitraryHookId = Symbol.for("@effect/schema/ArbitraryHookId"),
			EquivalenceHookId = Symbol.for("@effect/schema/EquivalenceHookId"),
			PrettyHookId = Symbol.for("@effect/schema/PrettyHookId"),
			Schema_TypeId = Symbol.for("@effect/schema/Schema"),
			Schema_make = ast =>
				class {
					[Schema_TypeId] = Schema_variance
					static Type
					static Encoded
					static [Schema_TypeId] = Schema_variance
					static ast = ast
					static annotations(annotations) {
						return Schema_make(mergeSchemaAnnotations(this.ast, annotations))
					}
					static pipe() {
						return Pipeable_pipeArguments(this, arguments)
					}
					static toString() {
						return String(ast)
					}
				},
			Schema_variance = { _A: _ => _, _I: _ => _, _R: _ => _ },
			toASTAnnotations = annotations => {
				if (!annotations) return {}
				const out = {},
					custom = Object.getOwnPropertySymbols(annotations)
				for (const sym of custom) out[sym] = annotations[sym]
				if (void 0 !== annotations.typeId) {
					const typeId = annotations.typeId
					if ("object" == typeof typeId) {
						out[TypeAnnotationId] = typeId.id
						out[typeId.id] = typeId.annotation
					} else out[TypeAnnotationId] = typeId
				}
				const move = (from, to) => {
					void 0 !== annotations[from] && (out[to] = annotations[from])
				}
				move("message", MessageAnnotationId)
				move("missingMessage", MissingMessageAnnotationId)
				move("identifier", IdentifierAnnotationId)
				move("title", TitleAnnotationId)
				move("description", DescriptionAnnotationId)
				move("examples", ExamplesAnnotationId)
				move("default", DefaultAnnotationId)
				move("documentation", DocumentationAnnotationId)
				move("jsonSchema", JSONSchemaAnnotationId)
				move("arbitrary", ArbitraryHookId)
				move("pretty", PrettyHookId)
				move("equivalence", EquivalenceHookId)
				move("concurrency", ConcurrencyAnnotationId)
				move("batching", BatchingAnnotationId)
				move("parseIssueTitle", ParseIssueTitleAnnotationId)
				move("parseOptions", ParseOptionsAnnotationId)
				return out
			},
			mergeSchemaAnnotations = (ast, annotations) =>
				AST_annotations(ast, toASTAnnotations(annotations)),
			InstanceOfTypeId = Symbol.for("@effect/schema/TypeId/InstanceOf"),
			instanceOf = (constructor, annotations) =>
				(function () {
					return Array.isArray(arguments[0])
						? ((options = arguments[1]),
							(annotations = arguments[2]),
							Schema_make(
								new Declaration(
									arguments[0].map(tp => tp.ast),
									(...typeParameters) =>
										options.decode(...typeParameters.map(Schema_make)),
									(...typeParameters) =>
										options.encode(...typeParameters.map(Schema_make)),
									toASTAnnotations(annotations),
								),
							))
						: ((is, annotations) => {
								const decodeUnknown = () => (input, _, ast) =>
									is(input)
										? ParseResult_succeed(input)
										: ParseResult_fail(new ParseResult_Type(ast, input))
								return Schema_make(
									new Declaration(
										[],
										decodeUnknown,
										decodeUnknown,
										toASTAnnotations(annotations),
									),
								)
							})(arguments[0], arguments[1])
					var options, annotations
				})(u => u instanceof constructor, {
					title: constructor.name,
					description: `an instance of ${constructor.name}`,
					pretty: () => String,
					typeId: { id: InstanceOfTypeId, annotation: { constructor } },
					...annotations,
				}),
			configEffect = (k, v) => c => () =>
				Effect_runPromise(c.provideLog(c.setConfig[k](v))),
			stepTiming = stepCount => `steps(${stepCount}, jump-end)`,
			setComputed = {
				useStepTiming: v => c => s =>
					Function_pipe(
						v ? stepTiming(Editable_value(s.timingStepCount)) : "linear",
						timingFunction => [
							{ ...s, timingFunction },
							configEffect("timingFunction", timingFunction)(c),
						],
					),
			},
			settingUI_setComputed = setComputed,
			setRange = keyA => keyB => bFn => vA => commander => s =>
				Function_pipe(
					Editable_value(vA),
					a => ({ a, b: bFn(a)(Editable_value(s[keyB])) }),
					({ a, b }) =>
						Function_pipe(
							[configEffect(keyA, a), configEffect(keyB, b)],
							xs => c =>
								Function_pipe(
									xs,
									Array_map(x => x(c)),
									effects => [
										{ ...s, [keyA]: vA, [keyB]: setValue(b)(s[keyB]) },
										...effects,
									],
								),
						)(commander),
				),
			setState = {
				flowY1: setRange("flowY1")("flowY2")(a => b => Math.max(b, a + 0.05)),
				flowY2: setRange("flowY2")("flowY1")(a => b => Math.min(b, a - 0.05)),
				flowX1: setRange("flowX1")("flowX2")(a => b => Math.max(b, a + 0.05)),
				flowX2: setRange("flowX2")("flowX1")(a => b => Math.min(b, a - 0.05)),
				timingStepCount: v => c => s =>
					Function_pipe(stepTiming(Editable_value(v)), timingFunction => [
						{ ...s, timingStepCount: v, timingFunction },
						configEffect("timingFunction", timingFunction)(c),
					]),
			},
			settingUI_setState = setState,
			updateAt = k => v =>
				Function_pipe(
					k in settingUI_setComputed
						? settingUI_setComputed[k](v)
						: k in settingUI_setState
							? settingUI_setState[k](v)
							: c => s => [
									{ ...s, [k]: v },
									...(k in c.setConfig && "filterExp" !== k
										? [
												configEffect(
													k,
													Array.isArray(v) &&
														2 === v.length &&
														isEditable(k)(v[0])
														? Editable_value(v)
														: v,
												)(c),
											]
										: []),
								],
				),
			updateBool = (
				updateAt => key =>
					flip((s, e) =>
						Function_pipe(
							(e =>
								decodeUnknownSync(instanceOf(HTMLInputElement))(e.currentTarget)
									.checked)(e),
							updateAt(key),
							flip,
							apply(s),
						),
					)
			)(updateAt),
			settingUI_checkboxNode = (
				(getText, getState, updateBool) => label => c => s =>
					((label, checked, onchange) =>
						h(
							"div",
							{},
							h("label", {}, [
								hyperapp_text(label),
								h("input", { type: "checkbox", checked, onchange }),
							]),
						))(getText(label)(s), getState(label)(s), updateBool(label)(c))
			)(getText, getState, updateBool),
			mapSettingNodes = f => xs => c => s =>
				Function_pipe(
					xs,
					Array_map(x => x(c)(s)),
					f,
				),
			errorText = subject => edit =>
				Function_pipe(
					edit,
					Editable_error,
					map(x => `${subject}${"" === x ? "" : ": "}${x}`),
					getOrElse(constant("")),
				),
			rangeRow = (config, action) => value =>
				h("div", {}, [
					h("input", {
						style: { width: "150px", verticalAlign: "middle" },
						type: "range",
						...config,
						value: Editable_value(value).toString(),
						oninput: action.onchange ?? Function_identity,
					}),
					h("input", {
						style: {
							width: "30px",
							backgroundColor: "transparent",
							color: "inherit",
							borderWidth: "1px",
							verticalAlign: "middle",
							borderColor: hasError(value) ? "#f55" : null,
						},
						inputmode: "decimal",
						value: Function_pipe(
							value,
							Editable_text,
							getOrElse(
								constant(
									Editable_value(value)
										.toFixed(4)
										.replace(/\.?0+$/, ""),
								),
							),
						),
						...action,
					}),
				]),
			settingRow = (label, error, content) =>
				h("div", {}, [
					h("span", {}, hyperapp_text(label)),
					h(
						"span",
						{
							style: {
								color: "#f55",
								marginLeft: "5px",
								whiteSpace: "pre-wrap",
							},
						},
						hyperapp_text(error),
					),
					h("div", {}, content),
				]),
			numericNode =
				setter =>
				(editAction, getText, getState) =>
				(label, min, max, step) =>
				c =>
				s =>
					settingRow(
						getText(label)(s),
						errorText(getText("inputNonNumberic")(s))(getState(label)(s)),
						[
							rangeRow(
								{ min, max, step },
								editAction(label, setter)(c),
							)(getState(label)(s)),
						],
					),
			numberNode = numericNode(
				editing => value => state =>
					Function_pipe(
						value,
						Number.parseFloat,
						editing
							? x =>
									Number.isNaN(x) || "." === value.at(-1)
										? Function_pipe(state, setText(value))
										: fromValueText(x)(value)
							: x =>
									Number.isNaN(x)
										? Function_pipe(
												state,
												mapSecond(
													constant(Option_some([value, Option_some("")])),
												),
											)
										: Editable_of(x),
					),
			),
			updateInput = (
				(getState, updateAt) => key => setter => c => (s, e) =>
					Function_pipe(
						(e => {
							const target = e.currentTarget ?? e.__target
							if (
								target instanceof HTMLSelectElement ||
								target instanceof HTMLTextAreaElement ||
								target instanceof HTMLInputElement
							)
								return target.value
							throw Error("Event target type isn't acceptable.")
						})(e),
						setter,
						apply(getState(key)(s)),
						updateAt(key),
						x => x(c)(s),
					)
			)(getState, updateAt),
			editAction = (updateInput => (key, setter) => c => ({
				oninput: updateInput(key)(setter(!0))(c),
				onchange: updateInput(key)(setter(!1))(c),
			}))(updateInput),
			settingUI_numberNode = numberNode(editAction, getText, getState),
			settingUI_chatFieldPanel = Function_pipe(
				[
					Function_pipe(
						[
							settingUI_numberNode("fieldScale", 0.7, 1.5, 0.05),
							settingUI_checkboxNode("simplifyChatField"),
							settingUI_checkboxNode("createBanButton"),
						],
						mapSettingNodes(x => h("div", { style: panelBoxStyle(644) }, x)),
					),
				],
				mapSettingNodes(Function_identity),
			),
			action = {
				copy: () => s =>
					Effect_map(
						Effect_promise(async () => {
							return GM.setClipboard(
								((x = s.eventLog),
								`<pre>${JSON.stringify({ nextId: x.nextId, blocks: Function_pipe(x.compressedBlocks, Array_map(external_LZString_namespaceObject.decompressFromUTF16), Array_append(JSON.stringify(x.lastBlock)), Array_map(external_LZString_namespaceObject.compressToEncodedURIComponent)) })}</pre>`),
							)
							var x
						}),
						() => s,
					),
				clearFlowChats: c => s => Effect_map(c.act.clearFlowChats, () => s),
				importLog: () => s =>
					Function_pipe(
						Effect_sync(() => prompt(getText("importLog")(s))),
						Effect_flatMap(Effect_fromNullable),
						Effect_map(x => ({ ...s, eventLog: importLog(x) })),
						Effect_orElseSucceed(() => s),
					),
			},
			buttonNode = label => c => state =>
				h(
					"button",
					{
						type: "button",
						onclick: s => [
							s,
							d =>
								Effect_runPromise(
									c.provideLog(
										Function_pipe(
											action[label](c)(s),
											Effect_flatMap(newS => Effect_sync(() => d(newS))),
										),
									),
								),
						],
					},
					hyperapp_text(getText(label)(state)),
				),
			feedbackPanel = c => s =>
				Function_pipe(
					getState("eventLog")(s).compressedBlocks.length + 1,
					logPageCount => [
						Function_pipe(
							[settingUI_checkboxNode("logEvents"), buttonNode("importLog")],
							mapSettingNodes(x => h("div", { style: panelBoxStyle(212) }, x)),
						)(c)(s),
						h("div", { style: panelBoxStyle(428) }, [
							h(
								"a",
								{
									style: { color: "#f0f" },
									href: "https://greasyfork.org/en/scripts/411442-flow-youtube-chat/feedback",
									target: "_blank",
								},
								hyperapp_text(getText("giveFeedback")(s)),
							),
							h("div", {}, [
								h("span", {}, hyperapp_text(getText("eventLog")(s))),
								buttonNode("copy")(c)(s),
								tabContainer({
									container: {},
									label: { padding: "4px", width: "2em", textAlign: "center" },
									labelFocus: { background: "#666" },
									tab: {
										height: "251px",
										display: "flex",
										flexDirection: "column",
										padding: "6px",
									},
								})((_, n) => updateAt("logTab")(n)(c))(
									Function_pipe(Array_makeBy(logPageCount, x => `${x}`)),
								)(
									Function_pipe(getState("eventLog")(s), l =>
										Array_makeBy(
											logPageCount,
											i => () =>
												Function_pipe(
													Array_get(l.compressedBlocks, i),
													map(decompressBlock),
													getOrElse(() => l.lastBlock),
													Array_map((x, j) =>
														h("div", { style: { display: "flex" } }, [
															h(
																"div",
																{
																	style: {
																		userSelect: "none",
																		flex: "0 0 2em",
																	},
																},
																hyperapp_text(x.id),
															),
															h(
																"div",
																{
																	style: {
																		background: j % 2 == 0 ? "#fff" : "#ddd",
																		color: "#000",
																		flex: "auto",
																		wordBreak: "break-all",
																		whiteSpace: "break-spaces",
																		padding: "0 2px",
																	},
																},
																hyperapp_text(`[${x.level}] ${x.text}`),
															),
														]),
													),
												),
										),
									),
								)(getState("logTab")(s)),
							]),
						]),
					],
				),
			textAreaRow = (rows, action) => value =>
				h("textarea", {
					rows,
					style: {
						resize: "none",
						boxSizing: "border-box",
						width: "100%",
						borderColor: hasError(value) ? "#f55" : null,
					},
					value: Function_pipe(
						value,
						Editable_text,
						getOrElse(
							Function_pipe(Editable_value(value), join("\n"), constant),
						),
					),
					...action,
				}),
			textAreaNode =
				setter => (editAction, getText, getState) => (label, rows) => c => s =>
					settingRow(
						getText(label)(s),
						errorText(getText("invalidSetting")(s))(getState(label)(s)),
						[
							textAreaRow(
								rows,
								editAction(label, setter)(c),
							)(getState(label)(s)),
						],
					),
			settingUI_plainTextAreaNode = textAreaNode(
				editing => value =>
					Function_pipe(
						value,
						String_split(/\r\n|\n/),
						Array_filter(not(String_isEmpty)),
						regexes => ({
							regexes,
							errors: Function_pipe(
								regexes,
								Array_map((x, i) => {
									try {
										RegExp(x, "u")
										return Option_none()
									} catch (e) {
										return Option_some(`${e} in regex number ${i}`)
									}
								}),
								Array_getSomes,
								Array_reduce("", (b, a) => `${b}\n${a}`),
								liftPredicate(String_isNonEmpty),
							),
						}),
						ctx =>
							editing
								? setText(value)
								: Function_pipe(
										ctx.errors,
										map(x =>
											mapSecond(() => Option_some([value, Option_some(x)])),
										),
										getOrElse(() => () => Editable_of(ctx.regexes)),
									),
					),
			)(editAction, getText, getState),
			settingUI_regexTextAreaNode = textAreaNode(
				editing => value =>
					Function_pipe(
						value,
						String_split(/\r\n|\n/),
						Array_filter(not(String_isEmpty)),
						x =>
							constant(
								editing
									? [x, Option_some([value, Option_none()])]
									: Editable_of(x),
							),
					),
			)(editAction, getText, getState),
			filterPanelOld = c => s => [
				h(
					"div",
					{ style: panelBoxStyle(212) },
					settingUI_plainTextAreaNode("bannedWords", 18)(c)(s),
				),
				h(
					"div",
					{ style: panelBoxStyle(212) },
					settingUI_regexTextAreaNode("bannedWordRegexes", 18)(c)(s),
				),
				h(
					"div",
					{ style: panelBoxStyle(212) },
					settingUI_plainTextAreaNode("bannedUsers", 18)(c)(s),
				),
			],
			colorPicker = action => color =>
				h("input", {
					style: { width: "36px", verticalAlign: "middle" },
					type: "color",
					value: color,
					oninput: action.onchange ?? Function_identity,
				}),
			textInput = action => value =>
				h("input", {
					style: {
						verticalAlign: "middle",
						width: "5.5em",
						borderColor: hasError(value) ? "#f55" : null,
					},
					maxlength: 20,
					value: Function_pipe(
						value,
						Editable_text,
						getOrElse(constant(Editable_value(value))),
					),
					...action,
				})
		var validate_color_lib = __webpack_require__(742),
			lib_default = __webpack_require__.n(validate_color_lib)
		const setter_setEditColor = editing => value =>
				editing
					? lib_default()(value)
						? constant(fromValueText(value)(value))
						: setText(value)
					: lib_default()(value)
						? constant(Editable_of(value))
						: mapSecond(constant(Option_some([value, Option_some("")]))),
			settingUI_colorNode = (
				(editAction, getText, getState) => label => c => s =>
					settingRow(
						getText(label)(s),
						errorText(getText("invalidColor")(s))(getState(label)(s)),
						Function_pipe(editAction(label, setter_setEditColor)(c), x => [
							colorPicker(x)(Editable_value(getState(label)(s))),
							textInput(x)(getState(label)(s)),
						]),
					)
			)(editAction, getText, getState),
			settingUI_intNode = numericNode(
				editing => value => state =>
					Function_pipe(
						value,
						Number.parseInt,
						editing
							? x =>
									Number.isNaN(x) || "." === value.at(-1)
										? Function_pipe(state, setText(value))
										: fromValueText(x)(value)
							: x =>
									Number.isNaN(x)
										? Function_pipe(
												state,
												mapSecond(
													constant(Option_some([value, Option_some("")])),
												),
											)
										: Editable_of(x),
					),
			)(editAction, getText, getState),
			setter_setEditString = editing => x =>
				constant(editing ? fromValueText(x)(x) : Editable_of(x)),
			fonts = currentFont => [
				["", "Default", "デフォルト", "Default"],
				["arial", "Arial", "Arial", "Arial"],
				["arial black", "Arial Black", "Arial Black", "Arial Black"],
				["arial narrow", "Arial Narrow", "Arial Narrow", "Arial Narrow"],
				["Century", "Century", "Century", "Century"],
				["Comic Sans MS", "Comic Sans MS", "Comic Sans MS", "Comic Sans MS"],
				["Courier", "Courier", "Courier", "Courier"],
				["cursive", "cursive", "cursive", "cursive"],
				["fantasy", "fantasy", "fantasy", "fantasy"],
				["Impact", "Impact", "Impact", "Impact"],
				["Meiryo", "Meiryo", "メイリオ", "Meiryo"],
				["Meiryo UI", "Meiryo UI", "メイリオ UI", "Meiryo UI"],
				["monospace", "monospace", "monospace", "monospace"],
				[
					"Monotype Corsiva",
					"Monotype Corsiva",
					"Monotype Corsiva",
					"Monotype Corsiva",
				],
				["MS PGothic", "MS PGothic", "MS Pゴシック", "MS PGothic"],
				["MS Gothic", "MS Gothic", "MS ゴシック", "MS Gothic"],
				["MS Sans Serif", "MS Sans Serif", "MS Sans Serif", "MS Sans Serif"],
				["MS Serif", "MS Serif", "MS Serif", "MS Serif"],
				["MS UI Gothic", "MS UI Gothic", "MS UI Gothic", "MS UI Gothic"],
				["sans-serif", "Sans-serif", "Sans-serif", "Sans-serif"],
				["serif", "Serif", "Serif", "Serif"],
				[
					"Times New Roman",
					"Times New Roman",
					"Times New Roman",
					"Times New Roman",
				],
				["Yu Gothic", "Yu Gothic", "遊ゴシック", "Yu Gothic"],
				["YuGothic", "YuGothic", "游ゴシック体", "YuGothic"],
				[currentFont, "Custom", "カスタム", "自定义"],
			],
			settingUI_textRowStyle = { width: "70%", boxSizing: "border-box" },
			colorTextOutput = textStyle => color =>
				h(
					"span",
					{ style: { ...textStyle, color } },
					hyperapp_text("Aa1あア亜"),
				),
			settingUI_textColorNode = (
				(editAction, getText, getState, getExampleTextStyle) =>
				label =>
				c =>
				s =>
					settingRow(
						getText(label)(s),
						errorText(getText("invalidColor")(s))(getState(label)(s)),
						Function_pipe(
							{
								a: editAction(label, setter_setEditColor)(c),
								v: Editable_value(getState(label)(s)),
							},
							({ a, v }) => [
								colorPicker(a)(v),
								textInput(a)(getState(label)(s)),
								colorTextOutput(getExampleTextStyle(s))(v),
							],
						),
					)
			)(editAction, getText, getState, s => ({
				fontFamily: Editable_value(s.font),
				fontWeight: Editable_value(s.fontWeight).toString(),
				textShadow: textShadow(Editable_value(s.shadowColor))(
					Editable_value(s.shadowFontWeight),
				),
			})),
			flowChatPanel = Function_pipe(
				[
					Function_pipe(
						[
							c => s =>
								Function_pipe(Editable_value(s.font), font =>
									settingRow(getText("font")(s), "", [
										h(
											"select",
											{
												style: settingUI_textRowStyle,
												onchange: updateInput("font")(setter_setEditString(!1))(
													c,
												),
											},
											Function_pipe(
												fonts(font),
												findFirstIndex(x => x[0] === font),
												getOrElse(() => 0),
												index =>
													Function_pipe(
														fonts(font),
														Array_map((f, i) =>
															node_option(
																f[0],
																Function_pipe(
																	languages,
																	findFirstIndex(x => x === s.lang),
																	map(x => Array_unsafeGet(x + 1)(f)),
																	getOrElse(() => "Error"),
																),
																i === index,
															),
														),
													),
											),
										),
										h("input", {
											style: settingUI_textRowStyle,
											maxlength: 20,
											value: font,
											...editAction("font", setter_setEditString),
										}),
									]),
								),
							settingUI_textColorNode("color"),
							settingUI_textColorNode("ownerColor"),
							settingUI_textColorNode("moderatorColor"),
							settingUI_textColorNode("memberColor"),
							settingUI_colorNode("shadowColor"),
						],
						mapSettingNodes(x => h("div", { style: panelBoxStyle(212) }, x)),
					),
					Function_pipe(
						[
							settingUI_numberNode("chatOpacity", 0, 1, 0.05),
							settingUI_numberNode("fontSize", 0.3, 2, 0.05),
							settingUI_numberNode("fontWeight", 10, 1e3, 10),
							settingUI_numberNode("shadowFontWeight", 0, 3, 0.1),
							settingUI_numberNode("flowSpeed", 1, 50, 1),
							settingUI_intNode("maxChatCount", 5, 200, 5),
							settingUI_intNode("maxChatLength", 5, 200, 5),
							settingUI_intNode("laneCount", 1, 25, 1),
						],
						mapSettingNodes(x => h("div", { style: panelBoxStyle(212) }, x)),
					),
					Function_pipe(
						[
							settingUI_numberNode("flowY1", 0, 0.95, 0.01),
							settingUI_numberNode("flowY2", 0.05, 1, 0.01),
							settingUI_numberNode("flowX1", 0, 0.95, 0.01),
							settingUI_numberNode("flowX2", 0.05, 1, 0.01),
							settingUI_numberNode("minSpacing", 0, 2.5, 0.1),
							c => s =>
								h("div", {}, [
									settingUI_checkboxNode("useStepTiming")(c)(s),
									h(
										"div",
										{
											style: {
												opacity: getState("useStepTiming")(s) ? null : "0.5",
											},
										},
										settingUI_intNode("timingStepCount", 1, 400, 1)(c)(s),
									),
								]),
							settingUI_checkboxNode("createChats"),
							settingUI_checkboxNode("displayModName"),
							settingUI_checkboxNode("displaySuperChatAuthor"),
							settingUI_checkboxNode("textOnly"),
							() => s => hyperapp_text(getText("flowNewChatIf")(s)),
							settingUI_checkboxNode("noOverlap"),
							buttonNode("clearFlowChats"),
						],
						mapSettingNodes(x => h("div", { style: panelBoxStyle(212) }, x)),
					),
				],
				mapSettingNodes(Function_identity),
			),
			settingUI_flowChatPanel = flowChatPanel,
			withMinimumLogLevel = Function_dual(2, (self, level) =>
				fiberRefLocally(currentMinimumLogLevel, level)(self),
			),
			Logger_make = makeLogger,
			Logger_replace = Function_dual(2, (self, that) =>
				layer_flatMap(
					scopedDiscard(
						fiberRefLocallyScopedWith(currentLoggers, HashSet_remove(self)),
					),
					() =>
						scopedDiscard(
							fiberRefLocallyScopedWith(currentLoggers, HashSet_add(that)),
						),
				),
			),
			Logger_withMinimumLogLevel = withMinimumLogLevel,
			Logger_zip = logger_zip,
			Logger_defaultLogger = defaultLogger
		var LogAnnotationKeys
		!(function (LogAnnotationKeys) {
			LogAnnotationKeys.name = "name"
		})(LogAnnotationKeys || (LogAnnotationKeys = {}))
		const src_LogAnnotationKeys = LogAnnotationKeys,
			maxEventLogBlockCount = Math.floor(50),
			preserveEventLogBlockCount = Math.floor(0.2 * maxEventLogBlockCount),
			Console_debug = (...args) => consoleWith(_ => _.debug(...args)),
			Console_error = (...args) => consoleWith(_ => _.error(...args)),
			Console_info = (...args) => consoleWith(_ => _.info(...args)),
			Console_log = (...args) => consoleWith(_ => _.log(...args)),
			Console_trace = (...args) => consoleWith(_ => _.trace(...args)),
			Console_warn = (...args) => consoleWith(_ => _.warn(...args)),
			getConsoleLog = x =>
				x === Trace
					? Console_trace
					: x === Debug
						? Console_debug
						: x === Info
							? Console_info
							: x === Warning
								? Console_warn
								: x === LogLevel_Error || x === Fatal
									? Console_error
									: Console_log,
			metaLogger = Logger_make(({ logLevel, message, context, annotations }) =>
				Effect_runPromise(
					Function_pipe(
						() =>
							`${Function_pipe(annotations, HashMap_get(src_LogAnnotationKeys.name), match({ onNone: () => "", onSome: x => `[${x}] ` }))}${message}`,
						getStr =>
							Function_pipe(
								FiberRefs_getOrDefault(context, logMeta),
								match({
									onNone: () =>
										greaterThanEqual(Warning)(logLevel)
											? getConsoleLog(logLevel)(getStr())
											: _void,
									onSome: meta =>
										Effect_sync(() =>
											getConsoleLog(logLevel)(`${getStr()}: `, meta),
										),
								}),
							),
					),
				),
			),
			provideLog = settingUpdateApps => effect => {
				return Function_pipe(
					Effect_succeed(
						Logger_replace(
							Logger_defaultLogger,
							Logger_zip(metaLogger)(
								((apps = settingUpdateApps),
								Logger_make(({ logLevel, message }) =>
									Effect_runPromise(
										(
											apps => dispatchable =>
												Function_pipe(
													apps,
													Effect_forEach(x =>
														Effect_sync(() => x(dispatchable)),
													),
												)
										)(apps.getValue())(s => {
											return s.logEvents
												? {
														...s,
														eventLog: ((text = String(message)),
														(level = logLevel.label),
														x =>
															Function_pipe(
																x.compressedBlocks.length ===
																	maxEventLogBlockCount
																	? (i => log =>
																			i > log.compressedBlocks.length
																				? log
																				: makeLog({
																						nextId: log.nextId,
																						...(i ===
																						log.compressedBlocks.length
																							? {
																									lastBlock: [],
																									compressedBlocks:
																										log.compressedBlocks,
																								}
																							: {
																									lastBlock: log.lastBlock,
																									compressedBlocks:
																										Array_remove(
																											log.compressedBlocks,
																											i,
																										),
																								}),
																					}))(
																			Math.floor(preserveEventLogBlockCount),
																		)(x)
																	: x,
																(
																	(text, level) => log =>
																		makeLog({
																			nextId: log.nextId + 1,
																			...Function_pipe(
																				log.lastBlock,
																				Array_append({
																					id: log.nextId,
																					text,
																					level,
																				}),
																				x =>
																					200 === x.length
																						? {
																								compressedBlocks: Array_append(
																									log.compressedBlocks,
																									makeCompressedLogBlock(
																										(0,
																										external_LZString_namespaceObject.compressToUTF16)(
																											JSON.stringify(x),
																										),
																									),
																								),
																								lastBlock: [],
																							}
																						: {
																								compressedBlocks:
																									log.compressedBlocks,
																								lastBlock: x,
																							},
																			),
																		})
																)(text, level),
															))(s.eventLog),
													}
												: s
											var text, level
										}),
									),
								)),
							),
						),
					),
					Effect_flatMap(logLayer =>
						Function_pipe(
							effect,
							Effect_tapErrorCause(x => Effect_logError(Cause_pretty(x))),
							Effect_provide(logLayer),
						),
					),
					Effect_annotateLogs(src_LogAnnotationKeys.name, "FYC"),
					Logger_withMinimumLogLevel(Debug),
				)
				var apps
			}
		Effect_runPromise(
			Function_pipe(
				Effect_gen(function* () {
					const settingUpdateApps =
						new external_rxjs_namespaceObject.BehaviorSubject([])
					yield* (({ settingUpdateApps, provideLog }) =>
						provideLog(
							Function_pipe(
								Effect_gen(function* () {
									const ctx = {
											updateSettingState: dispatchable =>
												provideLog(
													Function_pipe(
														Effect_succeed(settingUpdateApps.value),
														Effect_flatMap(
															Effect_forEach(x =>
																Effect_sync(() => x(dispatchable)),
															),
														),
													),
												),
											configSubject: makeSubject(configKeys),
											channel: new broadcast_channel_BroadcastChannel(
												"fyc-0615654655528523",
											),
											configValue: yield* ((config = src_defaultGMConfig),
											Function_pipe(
												Object.entries(config),
												Effect_forEach(([k, c]) =>
													c.getValue.pipe(Effect_map(x => [k, x])),
												),
												Effect_map(Object.fromEntries),
											)),
										},
										setterFromMap =
											((keys = configKeys),
											f =>
												Function_pipe(
													keys,
													Array_map(x => [x, f(x)]),
													Object.fromEntries,
												)),
										setConfigPlain = setterFromMap(
											key => val =>
												Effect_sync(() => {
													Object.assign(ctx.configValue, { [key]: val })
													ctx.configSubject[key].next(val)
												}),
										)
									var keys, config
									yield* setConfigPlain.filterExp(
										defaultFilter(ctx.configValue),
									)
									const changedConfigMap = key => val =>
										Function_pipe(
											Effect_sync(() => ctx.configValue[key]),
											Effect_filterOrFail(
												x => !fast_deep_equal_default()(x, val),
											),
											Effect_flatMap(() => setConfigPlain[key](val)),
										)
									return {
										...ctx,
										setChangedConfig: setterFromMap(
											key => val =>
												changedConfigMap(key)(val).pipe(Effect_ignore),
										),
										mainState: {
											chatPlaying: yield* SynchronizedRef_make(!0),
											playerRect: yield* SynchronizedRef_make(
												new DOMRectReadOnly(0, 0, 600, 400),
											),
											flowChats: yield* SynchronizedRef_make([]),
											config: {
												value: ctx.configValue,
												getConfig: makeGetter(ctx.configValue),
												setConfig: setterFromMap(
													key => val =>
														changedConfigMap(key)(val).pipe(
															Effect_zipRight(
																Effect_promise(() =>
																	ctx.channel.postMessage([key, val]),
																),
															),
															Effect_zipRight(
																Effect_promise(() =>
																	Function_pipe(src_defaultGMConfig[key], x =>
																		GM.setValue(x.gmKey, x.toGm(val)),
																	),
																),
															),
															Effect_ignore,
														),
												),
											},
										},
									}
								}),
								Effect_flatMap(ctx =>
									Effect_gen(function* () {
										const stateInit = Function_pipe(
											(config = ctx.mainState.config.value),
											mapObject(([k, v]) => [
												k,
												isEditable(k)(v)
													? Editable_of(v)
													: "filterExp" === k
														? void 0
														: v,
											]),
											x => ({
												...x,
												showPanel: !1,
												mainTab: 0,
												logTab: 0,
												timingStepCount: Editable_of(
													parseInt(
														config.timingFunction.match(
															/^steps\((\d+),.+/,
														)?.[1] ?? "150",
														10,
													),
												),
												eventLog: makeLog({
													nextId: 0,
													compressedBlocks: [],
													lastBlock: [],
												}),
												panelRect: new DOMRectReadOnly(0, 0, 660, 395),
											}),
										)
										var config, updateState, command, setConfig
										return {
											...ctx,
											apps: {
												toggleChatButtonApp: yield* wrapApp(
													((setConfig = ctx.mainState.config.setConfig),
													Function_pipe(
														"button",
														makeComponent(
															tag => state =>
																Function_pipe(
																	getText(
																		state.displayChats
																			? "hideChats"
																			: "showChats",
																	)(state),
																	label =>
																		h(
																			tag,
																			{
																				class: "ytp-button",
																				style: {
																					background: "none",
																					border: "none",
																					cursor: "pointer",
																					float: "left",
																					fontSize: "1em",
																					height: "100%",
																					outline: "none",
																					overflow: "visible",
																					padding: "0 0 0em",
																					position: "relative",
																					width: "48px",
																					display: "flex",
																					alignItems: "center",
																				},
																				type: "button",
																				"aria-label": label,
																				title: label,
																				onclick: s =>
																					Function_pipe(
																						!s.displayChats,
																						displayChats => [
																							{ ...s, displayChats },
																							() =>
																								Effect_runPromise(
																									setConfig.displayChats(
																										displayChats,
																									),
																								),
																						],
																					),
																			},
																			[
																				h(
																					"svg",
																					{
																						style: { width: "36px" },
																						viewBox: "0 0 36 36",
																					},
																					[
																						h("path", {
																							class: "chat-button-path",
																							d: "m11 12h17q1 0 1 1v9q0 1-1 1h-1v2l-4-2h-12q-1 0-1-1v-9q0-1 1-1z",
																							fill: "#fff",
																							"fill-opacity": state.displayChats
																								? "1"
																								: "0",
																							stroke: "#fff",
																							"stroke-width": "2",
																						}),
																					],
																				),
																			],
																		),
																),
														),
													)),
													stateInit,
												),
												settingsApp: yield* wrapApp(
													((command = {
														setConfig: ctx.mainState.config.setConfig,
														act: {
															clearFlowChats: removeOldChats(
																ctx.mainState.flowChats,
															)(0),
														},
														provideLog,
													}),
													Function_pipe(
														(c => state => {
															return state.showPanel
																? h(
																		"div",
																		{
																			class: "fyc_panel",
																			style: {
																				backgroundColor: "rgba(30,30,30,0.9)",
																				position: "absolute",
																				zIndex: "66666",
																				color: "#fff",
																				fontSize: "14px",
																				overflow: "auto",
																				left: `${state.panelRect.x}px`,
																				top: `${state.panelRect.y}px`,
																				width: `${state.panelRect.width}px`,
																				height: `${state.panelRect.height}px`,
																				border: "solid 1px #666",
																				fontFamily: "MS PGothic",
																				lineHeight: "1.2",
																				colorScheme: "dark",
																			},
																		},
																		[
																			h(
																				"div",
																				{
																					style: {
																						position: "absolute",
																						inset: "3px 3px auto auto",
																					},
																				},
																				[
																					hyperapp_text("🌐"),
																					h(
																						"select",
																						{
																							onchange: updateInput("lang")(
																								((allowedStrings = languages),
																								value => state =>
																									Function_pipe(
																										value,
																										liftPredicate(x =>
																											Array_containsWith(
																												String_Equivalence,
																											)(allowedStrings, x),
																										),
																										getOrElse(() => state),
																									)),
																							)(c),
																						},
																						Function_pipe(
																							languages,
																							Array_zip(languageLabels),
																							Array_map(([lang, label]) =>
																								node_option(
																									lang,
																									label,
																									lang === state.lang,
																								),
																							),
																						),
																					),
																				],
																			),
																			tabContainer({
																				container: {},
																				label: { padding: "6px" },
																				labelFocus: { background: "#666" },
																				tab: {
																					height: "364px",
																					display: "flex",
																					padding: "6px",
																				},
																			})((s, n) =>
																				updateAt("mainTab")(n)(c)(s),
																			)(
																				Function_pipe(
																					[
																						"flowChat",
																						"chatFilter",
																						"chatField",
																						"feedback",
																					],
																					Array_map(getText),
																					Array_map(apply(state)),
																				),
																			)(
																				Function_pipe(
																					[
																						settingUI_flowChatPanel,
																						filterPanelOld,
																						settingUI_chatFieldPanel,
																						feedbackPanel,
																					],
																					Array_map(apply(c)),
																					Array_map(constant),
																					Array_map(flip),
																					Array_map(apply(state)),
																				),
																			)(getState("mainTab")(state)),
																		],
																	)
																: h("div", {})
															var allowedStrings
														})(command),
														panel =>
															makeComponent(
																tag => s =>
																	h(
																		tag,
																		{ style: { display: "contents" } },
																		panel(s),
																	),
															)("span"),
													)),
													stateInit,
												),
												toggleSettingsPanelApp: yield* wrapApp(
													((updateState = ctx.updateSettingState),
													Function_pipe(
														(
															updateState => (x, e) =>
																Function_pipe(
																	{ ...x, showPanel: !x.showPanel },
																	newState => [
																		newState,
																		x.showPanel
																			? () =>
																					decodeUnknownSync(
																						instanceOf(HTMLElement),
																					)(e.currentTarget).blur()
																			: () => {},
																		() =>
																			Effect_runPromise(
																				updateState(oldState => ({
																					...oldState,
																					...newState,
																				})),
																			),
																	],
																)
														)(updateState),
														toggle => state =>
															h(
																"button",
																{
																	class: "fyc_button",
																	style: {
																		background: "rgba(0,0,0,0)",
																		marginLeft: "10px",
																		whiteSpace: "nowrap",
																	},
																	onclick: toggle,
																},
																[
																	h(
																		"svg",
																		{
																			preserveAspectRatio: "xMidYMid meet",
																			viewBox: "0 0 640 640",
																			width: "15",
																			height: "15",
																			style: {
																				position: "relative",
																				top: "1px",
																			},
																		},
																		[
																			h(
																				"defs",
																				{},
																				h("path", {
																					id: "d1TbzTC1zI",
																					d: "M135 58c25 14 67 30 82 35-7 49 16 109-15 149-50 71-19 184 64 213 74 31 165-18 183-95-3-38 23-62 58-36l120 55c-39 10-106 35-72 85 40 38 1 71-29 98-29 53-70-17-109-5-46 22-25 109-96 85h-55c-24-31-21-103-80-84-32 32-70 31-93-9l-35-36c4-40 57-96-6-120-45 5-58-32-52-68 2-19-4-41 3-59 35-15 100-22 77-79-48-43 1-84 35-115 5-6 12-12 20-14zM577 2c52 3 72 62 62 106-5 51 19 117-27 155-18 24 8 49 11 74-39-8-98-46-146-60-55-1-111 2-167-2-52-15-57-76-52-121S242 52 282 18c38-30 88-11 132-16h163z",
																				}),
																			),
																			h("use", {
																				href: "#d1TbzTC1zI",
																				opacity: "1",
																				fill: "var(--iron-icon-fill-color, currentcolor)",
																				"fill-opacity": "1",
																			}),
																		],
																	),
																	h(
																		"span",
																		{
																			style: {
																				position: "relative",
																				top: "-2px",
																				marginLeft: "8px,",
																			},
																		},
																		hyperapp_text(getText("setting")(state)),
																	),
																],
															),
														button =>
															makeComponent(
																tag => s =>
																	h(
																		tag,
																		{
																			style: {
																				float: "left",
																				display: "flex",
																				minHeight: "100%",
																			},
																		},
																		button(s),
																	),
															)("span"),
													)),
													stateInit,
												),
											},
										}
									}),
								),
								Effect_tap(ctx =>
									Effect_sync(() =>
										settingUpdateApps.next(
											Array_map(
												[
													ctx.apps.settingsApp,
													ctx.apps.toggleSettingsPanelApp,
													ctx.apps.toggleChatButtonApp,
												],
												x => x.dispatch,
											),
										),
									),
								),
								Effect_tap(ctx =>
									Function_pipe(
										Effect_succeed([
											"Version: 1.19.2",
											`User Agent: ${window.navigator.userAgent}`,
											`GMConfig: ${JSON.stringify(ctx.mainState.config, void 0, "\t")}`,
										]),
										Effect_flatMap(Effect_forEach(x => Effect_logDebug(x))),
									),
								),
								Effect_zipLeft(
									Function_pipe(
										Effect_logDebug("10s..."),
										schedule(Schedule_fixed(seconds(10))),
										Effect_forkDaemon,
									),
								),
								Effect_flatMap(ctx =>
									Effect_gen(function* () {
										const reinitSubject =
												new external_rxjs_namespaceObject.Subject(),
											reinitialize = provideLog(
												Effect_sync(() => {
													requestAnimationFrame(() => lib(reinitSubject)())
												}),
											)
										;(yield* allStream(provideLog)({
											...ctx,
											reinitSubject,
											reinitialize,
											chatScreen: yield* makeChatScreen,
											co: Function_pipe(
												ctx.configSubject,
												mapObject(([k, value]) => [
													k,
													Function_pipe(
														value,
														tapEffect(v => {
															return provideLog(
																Function_pipe(
																	Effect_succeed(s => ({ ...s, [k]: v })),
																	Effect_zipLeft(
																		ctx.updateSettingState(
																			((key = k),
																			value => state => ({
																				...state,
																				[key]: isEditable(key)(value)
																					? setValue(value)(state[key])
																					: "filterExp" === key
																						? void 0
																						: value,
																			}))(v),
																		),
																	),
																	Effect_zipLeft(
																		Function_pipe(
																			[
																				"bannedWords",
																				"bannedUsers",
																				"bannedWordRegexes",
																			],
																			Array_containsWith(String_Equivalence)(k),
																			x =>
																				x
																					? ctx.mainState.config.setConfig.filterExp(
																							defaultFilter(
																								ctx.mainState.config.value,
																							),
																						)
																					: _void,
																		),
																	),
																	x =>
																		Effect_sync(() =>
																			setTimeout(
																				() => Effect_runPromise(provideLog(x)),
																				0,
																			),
																		),
																),
															)
															var key
														}),
														(0, external_rxjs_namespaceObject.share)(),
													),
												]),
											),
										})).subscribe({
											error: x =>
												Effect_runPromise(
													logWithMeta(LogLevel_Error)(`Stream Errored: ${x}`)(
														x,
													),
												),
											complete: () =>
												Effect_runPromise(Effect_logWarning("Stream complete")),
										})
										yield* reinitialize
									}),
								),
							),
						))({ settingUpdateApps, provideLog: provideLog(settingUpdateApps) })
				}),
				Effect_withConcurrency(30),
			),
		)
	})()
})()