Fs.js

/*:
 * @target MZ
 * @plugindesc
 * 🚩 Basic function library for RPG Maker plugins.
 * Version: 0.3.0
 * @author F_
 * @url https://github.com/f-space/rmmz-plugins
 *
 * @help
 *
 * Basic function library for RPG Maker plugins.
 *
 * ---
 * Copyright (c) 2020 F_
 * Released under the MIT license
 * https://github.com/f-space/rmmz-plugins/blob/master/LICENSE
 */

"use strict";

{
	const LinkedList = (() => {
		const make = () => node(null);

		const init = (node, value) => Object.assign(node, { value, prev: node, next: node });
		const node = value => init({}, value);
		const value = node => node.value;
		const first = list => list.next;
		const last = list => list.prev;

		const $set = (node, value) => { node.value = value; };

		const $insertBefore = (node, ref) => {
			const prev = ref.prev;
			node.prev = prev;
			node.next = ref;
			ref.prev = prev.next = node;
		};

		const $remove = node => {
			const { prev, next } = node;
			prev.next = next;
			next.prev = prev;
			node.prev = node.next = node;
		};

		return { make, node, value, first, last, $set, $insertBefore, $remove };
	})();

	const LruCache = (() => {
		const make = capacity => ({
			capacity: Math.max(capacity, 1),
			map: new Map(),
			list: LinkedList.make(),
		});

		const $get = (cache, key) => {
			const { map, list } = cache;
			const node = map.get(key);
			if (node !== undefined) {
				$touch(list, node);
				return LinkedList.value(node).value;
			} else {
				return undefined;
			}
		};

		const $set = (cache, key, value) => {
			const { capacity, map, list } = cache;
			const node = map.get(key);
			if (node !== undefined) {
				LinkedList.$set(node, value);
				$touch(cache, node);
			} else {
				while (map.size >= capacity) {
					$remove(map, LinkedList.last(list));
				}
				$add(map, list, LinkedList.node({ key, value }));
			}
		};

		const $touch = (list, node) => {
			LinkedList.$remove(node);
			LinkedList.$insertBefore(node, LinkedList.first(list));
		};

		const $add = (map, list, node) => {
			const { key } = LinkedList.value(node);
			map.set(key, node);
			LinkedList.$insertBefore(node, LinkedList.first(list));
		};

		const $remove = (map, node) => {
			const { key } = LinkedList.value(node);
			map.delete(key);
			LinkedList.$remove(node);
		};

		return { make, $get, $set };
	})();

	const Monad = (unit, bind) => {
		const map = (monad, fn) => bind(monad, value => unit(fn(value)));
		const zip = monads => zipRec(monads, []);
		const zipRec = (ms, xs) => ms.length !== 0 ? bind(ms[0], x => zipRec(ms.slice(1), [...xs, x])) : unit(xs);
		const zipL = monads => zipLRec(monads, []);
		const zipLRec = (ms, xs) => ms.length !== 0 ? bind(ms[0](), x => zipLRec(ms.slice(1), [...xs, x])) : unit(xs);

		return { map, zip, zipL };
	};

	const panic = message => { throw new Error(message); };
	const try_ = (fn, handler) => { try { return fn(); } catch (e) { return handler(e); } };

	const O = (() => {
		const some = value => ({ value });
		const none = () => undefined;
		const unwrap = option => option.value;
		const isSome = option => option !== undefined;
		const isNone = option => option === undefined;
		const andThen = (option, fn) => isSome(option) ? fn(unwrap(option)) : option;
		const orElse = (option, fn) => isSome(option) ? option : fn();
		const match = (option, onSome, onNone) => isSome(option) ? onSome(unwrap(option)) : onNone();
		const expect = (option, formatter) => isSome(option) ? unwrap(option) : panic(formatter());
		const withDefault = (option, value) => isSome(option) ? unwrap(option) : value;
		const { map, zip, zipL } = Monad(some, andThen);

		return { some, none, unwrap, isSome, isNone, andThen, orElse, match, expect, withDefault, map, zip, zipL };
	})();

	const R = (() => {
		const ok = value => ({ value });
		const err = error => ({ error });
		const unwrap = result => result.value;
		const unwrapErr = result => result.error;
		const isOk = result => result.hasOwnProperty("value");
		const isErr = result => !isOk(result);
		const andThen = (result, fn) => isOk(result) ? fn(unwrap(result)) : result;
		const orElse = (result, fn) => isOk(result) ? result : fn(unwrapErr(result));
		const match = (result, onOk, onErr) => isOk(result) ? onOk(unwrap(result)) : onErr(unwrapErr(result));
		const expect = (result, formatter) => isOk(result) ? unwrap(result) : panic(formatter(unwrapErr(result)));
		const attempt = fn => try_(() => ok(fn()), err);
		const mapBoth = (result, mapOk, mapErr) => match(result, value => ok(mapOk(value)), error => err(mapErr(error)));
		const { map: map, zip: all, zipL: allL } = Monad(ok, andThen);
		const { map: mapErr, zip: any, zipL: anyL } = Monad(err, orElse);

		return { ok, err, unwrap, unwrapErr, isOk, isErr, andThen, orElse, match, expect, attempt, mapBoth, map, mapErr, all, any, allL, anyL };
	})();

	const L = (() => {
		const nil = () => null;
		const cons = (x, xs) => [x, xs];
		const singleton = x => cons(x, nil());
		const empty = list => list === null;
		const head = list => list[0];
		const tail = list => list[1];
		const match = (list, onNil, onCons) => empty(list) ? onNil() : onCons(head(list), tail(list));
		const find = (list, fn) => empty(list) ? undefined : fn(head(list)) ? head(list) : find(tail(list), fn);
		const some = (list, fn) => empty(list) ? false : fn(head(list)) ? true : some(tail(list), fn);
		const every = (list, fn) => empty(list) ? true : fn(head(list)) ? every(tail(list), fn) : false;
		const reverse = list => reverseRec(list, nil());
		const reverseRec = (list, acc) => empty(list) ? acc : reverseRec(tail(list), cons(head(list), acc));
		const reduce = (list, fn, value) => empty(list) ? value : reduce(tail(list), fn, fn(value, head(list)));
		const reduceRight = (list, fn, value) => reduce(reverse(list), fn, value);
		const map = (list, fn) => reduceRight(list, (xs, x) => cons(fn(x), xs), nil());
		const toArray = list => reduce(list, (xs, x) => [...xs, x], []);

		return { nil, cons, singleton, empty, head, tail, match, find, some, every, reverse, reduce, reduceRight, map, toArray };
	})();

	const S = (() => {
		const ELLIPSIS = "...";
		const ellipsis = (s, length) => s.length > length ? s.slice(0, length - ELLIPSIS.length) + ELLIPSIS : s;

		const debug = (value, replacer) => {
			const rec = (value, context) => {
				const { replacer } = context;
				const v = replacer !== undefined ? replacer(value) : value;
				switch (typeof v) {
					case 'undefined': return String(v);
					case 'number': return String(v);
					case 'string': return JSON.stringify(v);
					case 'boolean': return String(v);
					case 'symbol': return String(v);
					case 'bigint': return `${v}n`;
					case 'object': return object(v, context);
					case 'function': return `[Function: ${name(v)}]`;
					default: return "<unknown>";
				}
			};

			const name = ({ name }) => typeof name === 'string' && name !== "" ? name : "(anonymous)";

			const object = (value, context) => {
				const { stack } = context;
				if (value === null) return "null";
				if (stack.includes(value)) return "...";
				return objectCore(value, { ...context, stack: [...stack, value] });
			};

			const objectCore = (value, context) => {
				const array = (value, step) => value.length !== 0 ? `[ ${value.map(step).join(", ")} ]` : "[]";

				const step = value => rec(value, context);
				if (Array.isArray(value)) return array(value, step);
				if (value instanceof RegExp) return String(value);
				if (value instanceof Date) return value.toISOString();
				return normalObject(value, step);
			};

			const normalObject = (value, step) => {
				const type = objectType(value);
				const entries = objectEntries(value, step);
				const label = type !== undefined ? `${type} ` : "";
				const contents = entries !== "" ? `{ ${entries} }` : "{}";
				return label + contents;
			};

			const objectType = value => {
				const prototype = Object.getPrototypeOf(value);
				if (prototype === null) return "(null)";
				if (prototype === Object.prototype) return undefined;
				return name(prototype.constructor);
			};

			const objectEntries = (value, step) => {
				const map = (value, step) => Array.from(value).map(entry => entry.map(step).join(" => ")).join(", ");
				const set = (value, step) => Array.from(value).map(step).join(", ");
				const other = (value, step) => Object.entries(value).map(([k, v]) => `${key(k)}: ${step(v)}`).join(", ");
				const key = s => /^[a-z_$][a-z0-9_$]*$/i.test(s) ? s : JSON.stringify(s);

				if (value instanceof Map) return map(value, step);
				if (value instanceof Set) return set(value, step);
				if (value instanceof WeakMap) return "<***>";
				if (value instanceof WeakSet) return "<***>";
				return other(value, step);
			};

			return rec(value, { replacer, stack: [] });
		};

		return { ellipsis, debug };
	})();

	const U = (() => {
		const simpleEqual = (a, b) => {
			const arrayEqual = (a, b, eq) => a.length === b.length && a.every((v, i) => eq(v, b[i]));
			const pojoEqual = (a, b, eq) => {
				const has = (obj, key) => obj.hasOwnProperty(key);
				const akeys = Object.keys(a);
				const bkeys = Object.keys(b);
				return akeys.length === bkeys.length && akeys.every(k => has(b, k) && eq(a[k], b[k]));
			};
			const isPojo = x => Object.getPrototypeOf(x) === Object.prototype;

			if (Object.is(a, b)) return true;
			if (typeof a !== typeof b) return false;
			if (typeof a !== 'object') return false;
			if (a === null || b === null) return false;
			if (Array.isArray(a)) return Array.isArray(b) && arrayEqual(a, b, simpleEqual);
			if (isPojo(a)) return isPojo(b) && pojoEqual(a, b, simpleEqual);
			return false;
		};

		const defaultSerialize = args => JSON.stringify(args);
		const memo = (fn, size, serialize = defaultSerialize) => {
			const cache = LruCache.make(size);
			return (...args) => {
				const key = serialize(args);
				const result = LruCache.$get(cache, key);
				if (result !== undefined) {
					return result.value;
				} else {
					const value = fn(...args);
					LruCache.$set(cache, key, { value });
					return value;
				}
			};
		};

		const defaultEq = (a, b) => a.every((v, i) => Object.is(v, b[i]));
		const memo1 = (fn, eq = defaultEq) => {
			let cache = null;
			return (...args) => {
				if (cache !== null && eq(cache.args, args)) {
					return cache.value;
				} else {
					const value = fn(...args);
					cache = { args, value };
					return value;
				}
			};
		};

		const memoW = fn => {
			const cache = new WeakMap();
			return obj => {
				if (cache.has(obj)) {
					return cache.get(obj);
				} else {
					const value = fn(obj);
					cache.set(obj, value);
					return value;
				}
			};
		};

		return { simpleEqual, memo, memo1, memoW };
	})();

	const G = (() => {
		const tokenError = ({ cache, ...context }, cause) => ({ type: 'token', context, cause });
		const eoiError = ({ cache, ...context }) => ({ type: 'eoi', context });
		const andError = ({ cache, ...context }, error) => ({ type: 'and', context, error });
		const notError = ({ cache, ...context }, value) => ({ type: 'not', context, value });
		const validationError = ({ cache, ...context }, cause) => ({ type: 'validation', context, cause });

		const token = accept => context => {
			const { source, position } = context;
			return R.match(
				accept(source, position),
				([value, position]) => R.ok([value, { ...context, position }]),
				cause => R.err(tokenError(context, cause)),
			);
		};

		const eoi = () => context => {
			const { source, position } = context;
			return position === source.length ? R.ok([null, context]) : R.err(eoiError(context));
		};

		const succeed = value => context => R.ok([value, context]);
		const fail = error => () => R.err(error);
		const andThen = (parser, fn) => context => R.andThen(parser(context), ([value, context]) => fn(value)(context));
		const orElse = (parser, fn) => context => R.orElse(parser(context), error => fn(error)(context));
		const if_ = (cond, then, else_) =>
			context => R.match(cond(context), ([value, context]) => then(value)(context), error => else_(error)(context));
		const map = (parser, fn) => context => R.map(parser(context), ([value, context]) => [fn(value), context]);
		const mapError = (parser, fn) => context => R.mapErr(parser(context), fn);
		const fromResult = result => R.match(result, succeed, fail);

		const sequence = (a, b) => andThen(a, v1 => map(b, v2 => L.cons(v2, v1)));
		const choice = (a, b) => orElse(a, e1 => mapError(b, e2 => L.cons(e2, e1)));
		const loop = (parser, acc) => if_(parser, value => loop(parser, L.cons(value, acc)), () => succeed(acc));
		const toArray = list => L.toArray(L.reverse(list));

		const seqOf = parsers => map(parsers.reduce(sequence, succeed(L.nil())), toArray);
		const oneOf = parsers => mapError(parsers.reduce(choice, fail(L.nil())), toArray);
		const optional = parser => choice(map(parser, O.some), succeed(O.none()));
		const many = parser => map(loop(parser, L.nil()), toArray);
		const many1 = parser => map(andThen(parser, value => loop(parser, L.singleton(value))), toArray);
		const and = (pred, parser) => context => R.match(pred(context), () => parser(context), error => R.err(andError(context, error)));
		const not = (pred, parser) => context => R.match(pred(context), ([value]) => R.err(notError(context, value)), () => parser(context));
		const ref = getter => context => getter()(context);
		const validate = (parser, validator) =>
			context => andThen(parser, value => fromResult(R.mapErr(validator(value), cause => validationError(context, cause))))(context);

		const memo = parser => context => {
			const { position, cache } = context;
			if (cache !== null && position < cache.length) {
				const list = cache[position];
				const entry = L.find(list, x => x.parser === parser);
				if (entry !== undefined) {
					return entry.result;
				} else {
					const result = parser(context);
					cache[position] = L.cons({ parser, result }, list);
					return result;
				}
			} else {
				return parser(context);
			}
		};

		const makeContext = (source, position, options = {}) => {
			const cache = options.noCache ? null : [...new Array(source.length).fill(L.nil())];
			return { source, position, cache };
		};

		const make = (parser, options) => (source, position = 0) =>
			R.map(parser(makeContext(source, position, options)), ([value, { position }]) => [value, position]);

		const mk = (parser, options) => source =>
			R.map(parser(makeContext(source, 0, options)), ([value]) => value);

		const parse = (source, parser, errorFormatter = defaultErrorFormatter) => R.expect(parser(source), errorFormatter);

		const makeDefaultErrorFormatter = (tokenErrorFormatter, validationErrorFormatter) => {
			const dots = s => S.ellipsis(s, 16);
			const rest = ({ source: s, position: i }) => typeof s == 'string' ? `"${dots(s.slice(i))}"` : S.debug(s[i]);
			const pick = error => {
				const reduce = errors => errors.reduce((acc, e) => choice(acc, pick(e)), undefined);
				const choice = (a, b) => priority(a) >= priority(b) ? a : b;
				const priority = e => e?.context.position ?? -Infinity;
				return Array.isArray(error) ? reduce(error) : error;
			};
			const message = error => {
				switch (error?.type) {
					case 'token': return tokenErrorFormatter(error.cause);
					case 'eoi': return `end-of-input expected, but ${rest(error.context)} found`;
					case 'and': return `and-predicate failed at ${rest(error.context)}`;
					case 'not': return `not-predicate failed at ${rest(error.context)}`;
					case 'validation': return validationErrorFormatter(error.cause);
					default: return `unknown error: ${S.debug(error)}`;
				}
			};
			return error => message(pick(error));
		};

		const simpleErrorFormatter = error => typeof error === 'string' ? error : S.debug(error);

		const defaultErrorFormatter = makeDefaultErrorFormatter(simpleErrorFormatter, simpleErrorFormatter);

		return {
			token,
			eoi,
			succeed,
			fail,
			andThen,
			orElse,
			if: if_,
			map,
			mapError,
			seqOf,
			oneOf,
			optional,
			many,
			many1,
			and,
			not,
			ref,
			validate,
			memo,
			make,
			mk,
			parse,
			makeDefaultErrorFormatter,
			defaultErrorFormatter,
		};
	})();

	const E = (() => {
		const NUMBER = 'number';
		const BOOLEAN = 'boolean';
		const ANY = 'any';

		const Lexer = (() => {
			const RE_WHITESPACE = /^[ \t\r\n]*/;
			const RE_DECIMAL_DIGITS = `(?:[0-9]+(?:_[0-9]+)*)`;
			const RE_DECIMAL_INTEGER_LITERAL = `(?:0(?![bBoOxX])|[1-9](?:_?${RE_DECIMAL_DIGITS})?)`;
			const RE_EXPORNENT_PART = `(?:[eE][+-]?${RE_DECIMAL_DIGITS})`;
			const RE_DECIMAL_LITERAL =
				`(?:(?:${RE_DECIMAL_INTEGER_LITERAL}(?:\\.${RE_DECIMAL_DIGITS}?)?|\\.${RE_DECIMAL_DIGITS})${RE_EXPORNENT_PART}?)`;
			const RE_BINARY_INTEGER_LITERAL = `(?:0[bB][0-1]+(?:_[0-1]+)*)`;
			const RE_OCTAL_INTEGER_LITERAL = `(?:0[oO][0-7]+(?:_[0-7]+)*)`;
			const RE_HEX_INTEGER_LITERAL = `(?:0[xX][0-9a-fA-F]+(?:_[0-9a-fA-F]+)*)`;
			const RE_NON_DECIMAL_INTEGER_LITERAL =
				`(?:${RE_BINARY_INTEGER_LITERAL}|${RE_OCTAL_INTEGER_LITERAL}|${RE_HEX_INTEGER_LITERAL})`;
			const RE_NUMERIC_LITERAL = `(?:${RE_DECIMAL_LITERAL}|${RE_NON_DECIMAL_INTEGER_LITERAL})`;
			const RE_NUMBER = new RegExp(`^${RE_NUMERIC_LITERAL}`);
			const RE_BOOLEAN = /^(?:true|false)\b/;
			const RE_IDENTIFIER = /^[a-z$][a-z0-9$_]*/i;
			const RE_UNKNOWN = /^(?:[a-z0-9$_]+|[\p{L}\p{N}\p{Pc}\p{M}\p{Cf}]+|[\p{P}\p{S}]+|[^ \t\r\n]+)/iu;

			const next = (type, text, position) => [{ type, text, position }, position + text.length];

			const symbol = symbol => G.token((source, position) => {
				return source.startsWith(symbol, position) ? R.ok(next(symbol, symbol, position)) : R.err(symbol);
			});

			const regexp = (type, re) => G.memo(G.token((source, position) => {
				const match = source.slice(position).match(re);
				return match !== null ? R.ok(next(type, match[0], position)) : R.err(type);
			}));

			return {
				"!": symbol("!"),
				"!==": symbol("!=="),
				"%": symbol("%"),
				"&&": symbol("&&"),
				"(": symbol("("),
				")": symbol(")"),
				"*": symbol("*"),
				"**": symbol("**"),
				"+": symbol("+"),
				",": symbol(","),
				"-": symbol("-"),
				".": symbol("."),
				"/": symbol("/"),
				":": symbol(":"),
				"<": symbol("<"),
				"<=": symbol("<="),
				"===": symbol("==="),
				">": symbol(">"),
				">=": symbol(">="),
				"?": symbol("?"),
				"[": symbol("["),
				"]": symbol("]"),
				"||": symbol("||"),
				"whitespace": regexp("whitespace", RE_WHITESPACE),
				"number": regexp("number", RE_NUMBER),
				"boolean": regexp("boolean", RE_BOOLEAN),
				"identifier": regexp("identifier", RE_IDENTIFIER),
				"unknown": regexp("unknown", RE_UNKNOWN),
			};
		})();

		const parser = (() => {
			const numberNode = value => ({ type: 'number', value });
			const booleanNode = value => ({ type: 'boolean', value });
			const identifierNode = name => ({ type: 'identifier', name });
			const memberAccessNode = (object, property) => ({ type: 'member-access', object, property });
			const elementAccessNode = (array, index) => ({ type: 'element-access', array, index });
			const functionCallNode = (callee, args) => ({ type: 'function-call', callee, args });
			const unaryOpNode = (operator, expr) => ({ type: 'unary-operator', operator, expr });
			const binaryOpNode = (operator, lhs, rhs) => ({ type: 'binary-operator', operator, lhs, rhs });
			const condOpNode = (if_, then, else_) => ({ type: 'conditional-operator', if: if_, then, else: else_ });

			const token = type => (parser => G.andThen(Lexer.whitespace, () => parser))(Lexer[type]);
			const fail = type => G.token(() => R.err(type));

			const number = G.map(token("number"), value => numberNode(value));
			const boolean = G.map(token("boolean"), value => booleanNode(value));
			const identifier = G.map(token("identifier"), name => identifierNode(name));

			const group = (term, expr) => {
				const succ = G.andThen(expr, node => G.map(token(")"), () => node));
				return G.if(token("("), () => succ, () => term);
			};

			const postfixOp = (term, expr) => {
				const cont = G.ref(() => rec);
				const cases = [
					memberAccess(cont),
					elementAccess(expr, cont),
					functionCall(expr, cont),
				];
				const rec = cases.reduceRight((next, case_) => case_(next), G.succeed(node => node));
				return G.andThen(term, node => G.map(rec, ctor => ctor(node)));
			};

			const memberAccess = cont => next => {
				const succ = G.map(
					G.seqOf([identifier, cont]),
					([property, ctor]) => object => ctor(memberAccessNode(object, property)),
				);
				return G.if(token("."), () => succ, () => next);
			};

			const elementAccess = (expr, cont) => next => {
				const succ = G.map(
					G.seqOf([expr, token("]"), cont]),
					([index, , ctor]) => array => ctor(elementAccessNode(array, index)),
				);
				return G.if(token("["), () => succ, () => next);
			};

			const functionCall = (expr, cont) => next => {
				const succ = G.map(
					G.seqOf([functionArgs(expr), token(")"), cont]),
					([args, , ctor]) => callee => ctor(functionCallNode(callee, args)),
				);
				return G.if(token("("), () => succ, () => next);
			};
			const functionArgs = expr => {
				const rec = G.andThen(expr, node => G.if(
					token(","),
					() => G.orElse(G.and(token(")"), G.succeed(L.singleton(node))), () => G.map(rec, rest => L.cons(node, rest))),
					() => G.succeed(L.singleton(node)),
				));
				return G.orElse(G.not(expr, G.succeed([])), () => G.map(rec, L.toArray));
			};

			const unaryOp = (term, op) => {
				const rec = G.if(
					op,
					operator => G.map(rec, expr => unaryOpNode(operator, expr)),
					() => term,
				);
				return rec;
			};

			const binaryOpL = (term, op) => G.map(binaryOpList(term, op), list => L.reduce(list, binaryOpReducerL, [])[0]);
			const binaryOpReducerL = (xs, x) => xs.length == 2 ? [binaryOpNode(xs[1], xs[0], x)] : [...xs, x];
			const binaryOpR = (term, op) => G.map(binaryOpList(term, op), list => L.reduceRight(list, binaryOpReducerR, [])[0]);
			const binaryOpReducerR = (xs, x) => xs.length == 2 ? [binaryOpNode(xs[1], x, xs[0])] : [...xs, x];
			const binaryOpList = (term, op) => {
				const rec = G.andThen(term, lhs => G.if(
					op,
					operator => G.map(rec, rhs => L.cons(lhs, L.cons(operator, rhs))),
					() => G.succeed(L.singleton(lhs)),
				));
				return rec;
			};

			const condOp = (term, expr) => {
				const succ = G.seqOf([expr, token(":"), G.ref(() => rec)]);
				const rec = G.andThen(term, if_ => G.if(
					token("?"),
					() => G.map(succ, ([then, , else_]) => condOpNode(if_, then, else_)),
					() => G.succeed(if_),
				));
				return rec;
			};

			const expression = G.ref(() => exprL0);
			const exprL11 = G.memo(G.orElse(G.oneOf([number, boolean, identifier]), () => fail('expression')));
			const exprL10 = G.memo(group(exprL11, expression));
			const exprL9 = G.memo(postfixOp(exprL10, expression));
			const exprL8 = G.memo(unaryOp(exprL9, G.oneOf(["+", "-", "!"].map(token))));
			const exprL7 = G.memo(binaryOpR(exprL8, token("**")));
			const exprL6 = G.memo(binaryOpL(exprL7, G.oneOf(["*", "/", "%"].map(token))));
			const exprL5 = G.memo(binaryOpL(exprL6, G.oneOf(["+", "-"].map(token))));
			const exprL4 = G.memo(binaryOpL(exprL5, G.oneOf(["<=", ">=", "<", ">"].map(token))));
			const exprL3 = G.memo(binaryOpL(exprL4, G.oneOf(["===", "!=="].map(token))));
			const exprL2 = G.memo(binaryOpL(exprL3, token("&&")));
			const exprL1 = G.memo(binaryOpL(exprL2, token("||")));
			const exprL0 = G.memo(condOp(exprL1, expression));

			return expression;
		})();

		const parse = (() => {
			const tail = G.andThen(Lexer.whitespace, () => G.eoi());
			const whole = G.andThen(parser, value => G.map(tail, () => value));
			return G.mk(whole);
		})();

		const build = (() => {
			const BUILTIN_VARS = { Infinity, NaN, Math };
			const MEMBER_BLOCK_LIST = ["prototype", "constructor"];
			const VALUE_BLOCK_LIST = new Map([
				[globalThis, "global object"],
				[Object, "Object"],
				[Object.prototype, "Object.prototype"],
				[Function, "Function"],
				[Function.prototype, "Function.prototype"],
			]);

			const referenceError = name => ({ type: 'reference', name });
			const propertyError = property => ({ type: 'property', property });
			const rangeError = index => ({ type: 'range', index });
			const typeError = (expected, actual) => ({ type: 'type', expected, actual });
			const securityError = target => ({ type: 'security', target });

			const builtinValue = name => BUILTIN_VARS.hasOwnProperty(name) ? O.some(BUILTIN_VARS[name]) : O.none();
			const blockedMember = name => MEMBER_BLOCK_LIST.includes(name) ? O.some(`${name} property`) : O.none();
			const blockedValue = value => VALUE_BLOCK_LIST.has(value) ? O.some(VALUE_BLOCK_LIST.get(value)) : O.none();

			const bind = fn => a => R.andThen(a, fn);
			const bindL2 = fn => (a, b) => R.andThen(a(), a => R.andThen(b(), b => fn(a, b)));
			const liftL1 = fn => a => R.map(a(), a => fn(a));
			const liftL2 = fn => (a, b) => R.andThen(a(), a => R.map(b(), b => fn(a, b)));
			const liftL3 = fn => (a, b, c) => R.andThen(a(), a => R.andThen(b(), b => R.map(c(), c => fn(a, b, c))));

			const type = (name, fn) => bind(value => fn(value) ? R.ok(value) : R.err(typeError(name, value)));
			const isNumber = type('number', value => typeof value === 'number');
			const isInteger = type('integer', value => typeof value === 'number' && Number.isSafeInteger(value));
			const isBoolean = type('boolean', value => typeof value === 'boolean');
			const isFunction = type('function', value => typeof value === 'function');
			const isObject = type('object', value => (typeof value === 'object' && value !== null) || typeof value === 'function');
			const isArray = type('array', value => Array.isArray(value));
			const secure = bind(value => O.match(blockedValue(value), target => R.err(securityError(target)), () => R.ok(value)));

			const member = bindL2((object, property) => property in object ? R.ok(object[property]) : R.err(propertyError(property)));
			const element = bindL2((array, index) => index >= 0 && index < array.length ? R.ok(array[index]) : R.err(rangeError(index)));
			const callStatic = liftL2((fn, args) => fn(...args));
			const callMember = liftL3((this_, fn, args) => fn.apply(this_, args));
			const unary = liftL1;
			const binary = liftL2;

			const build = (type, node) => {
				const ensureType = typeContract(type);
				const evalExpr = expression(node);
				return env => ensureType(evalExpr(env));
			};

			const typeContract = type => {
				switch (type) {
					case NUMBER: return isNumber;
					case BOOLEAN: return isBoolean;
					case ANY: return x => x;
					default: return panic(`unsupported expression type: ${type}`);
				}
			};

			const expression = node => {
				const { type } = node;
				switch (type) {
					case 'number': return number(node);
					case 'boolean': return boolean(node);
					case 'identifier': return identifier(node);
					case 'member-access': return memberAccess(node);
					case 'element-access': return elementAccess(node);
					case 'function-call': return functionCall(node);
					case 'unary-operator': return unaryOp(node);
					case 'binary-operator': return binaryOp(node);
					case 'conditional-operator': return condOp(node);
					default: return panic(`invalid AST node type: ${type}`);
				}
			};

			const number = node => {
				const value = Number(node.value.text.replace(/_/g, ""));
				return () => R.ok(value);
			};

			const boolean = node => {
				const value = node.value.text === 'true';
				return () => R.ok(value);
			};

			const identifier = node => {
				const name = node.name.text;
				return O.match(
					builtinValue(name),
					value => () => R.ok(value),
					() => env => env.hasOwnProperty(name) ? R.ok(env[name]) : R.err(referenceError(name)),
				);
			};

			const memberAccess = node => {
				const { evalThis, evalExpr } = memberAccessCore(node);
				return env => evalExpr(evalThis(env), env);
			};
			const memberAccessCore = node => {
				const evalObject = expression(node.object);
				const property = node.property.name.text;
				return {
					evalThis: evalObject,
					evalExpr: O.match(
						blockedMember(property),
						target => () => R.err(securityError(target)),
						() => this_ => secure(member(() => isObject(this_), () => R.ok(property))),
					),
				};
			};

			const elementAccess = node => {
				const { evalThis, evalExpr } = elementAccessCore(node);
				return env => evalExpr(evalThis(env), env);
			};
			const elementAccessCore = node => {
				const evalArray = expression(node.array);
				const evalIndex = expression(node.index);
				return {
					evalThis: evalArray,
					evalExpr: (this_, env) => secure(element(() => isArray(this_), () => isInteger(evalIndex(env)))),
				};
			};

			const functionCall = node => {
				const callee = functionCallee(node.callee);
				const evalArgs = functionArgs(node.args);
				return callee.isStatic
					? functionStaticCall(callee.eval, evalArgs)
					: functionMemberCall(callee.evalThis, callee.evalExpr, evalArgs);
			};
			const functionCallee = node => {
				switch (node.type) {
					case 'member-access': return { isStatic: false, ...memberAccessCore(node) };
					case 'element-access': return { isStatic: false, ...elementAccessCore(node) };
					default: return { isStatic: true, eval: expression(node) };
				}
			};
			const functionArgs = nodes => {
				const evalList = nodes.map(node => expression(node));
				return env => R.allL(evalList.map(evalArg => () => evalArg(env)));
			};
			const functionStaticCall = (evalCallee, evalArgs) => {
				return env => secure(callStatic(() => isFunction(evalCallee(env)), () => evalArgs(env)));
			};
			const functionMemberCall = (evalThis, evalExpr, evalArgs) => {
				return env => {
					const this_ = evalThis(env);
					return secure(callMember(() => this_, () => isFunction(evalExpr(this_, env)), () => evalArgs(env)));
				};
			};

			const unaryOp = node => {
				const operator = node.operator.text;
				const evalExpr = expression(node.expr);
				switch (operator) {
					case '+': return env => unary(a => +a)(() => isNumber(evalExpr(env)));
					case '-': return env => unary(a => -a)(() => isNumber(evalExpr(env)));
					case '!': return env => unary(a => !a)(() => isBoolean(evalExpr(env)));
					default: return panic(`unsupported unary operator: ${operator}`);
				}
			};

			const binaryOp = node => {
				const operator = node.operator.text;
				const evalL = expression(node.lhs);
				const evalR = expression(node.rhs);
				switch (operator) {
					case '+': return env => binary((a, b) => a + b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '-': return env => binary((a, b) => a - b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '*': return env => binary((a, b) => a * b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '/': return env => binary((a, b) => a / b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '%': return env => binary((a, b) => a % b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '**': return env => binary((a, b) => a ** b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '===': return env => binary((a, b) => a === b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '!==': return env => binary((a, b) => a !== b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '<=': return env => binary((a, b) => a <= b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '>=': return env => binary((a, b) => a >= b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '<': return env => binary((a, b) => a < b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '>': return env => binary((a, b) => a > b)(() => isNumber(evalL(env)), () => isNumber(evalR(env)));
					case '&&': return env => R.andThen(isBoolean(evalL(env)), value => value ? isBoolean(evalR(env)) : R.ok(false));
					case '||': return env => R.andThen(isBoolean(evalL(env)), value => value ? R.ok(true) : isBoolean(evalR(env)));
					default: return panic(`unsupported binary operator: ${operator}`);
				}
			};

			const condOp = node => {
				const { if: if_, then, else: else_ } = node;
				const evalIf = expression(if_);
				const evalThen = expression(then);
				const evalElse = expression(else_);
				return env => R.andThen(isBoolean(evalIf(env)), value => value ? evalThen(env) : evalElse(env));
			};

			return build;
		})();

		const compile = (type, source) => R.map(parse(source), node => build(type, node));

		const expect = (result, errorFormatter = defaultCompileErrorFormatter) =>
			R.expect(result, errorFormatter);

		const run = (evaluator, env, errorFormatter = defaultRuntimeErrorFormatter) =>
			R.expect(evaluator(env), errorFormatter);

		const interpret = (type, source, env, parseErrorFormatter, runtimeErrorFormatter) =>
			run(expect(compile(type, source), parseErrorFormatter), env, runtimeErrorFormatter);

		const defaultCompileErrorFormatter = error => {
			const tokenize = G.make(G.andThen(Lexer.whitespace, () => Lexer.unknown));
			const sample = (source, position) => R.match(tokenize(source, position), ([token]) => token, () => undefined);
			const formatTokenError = error => {
				const { context: { source, position }, cause: expected } = error;
				const token = sample(source, position);
				const found = token !== undefined ? `"${token.text}"` : "no more tokens";
				return `'${expected}' expected, but ${found} found`;
			};
			const formatEoiError = error => {
				const { context: { source, position } } = error;
				const token = sample(source, position);
				const found = `"${token.text}"`;
				return `end-of-input expected, but ${found} found`;
			};
			switch (error?.type) {
				case 'token': return formatTokenError(error);
				case 'eoi': return formatEoiError(error);
				default: return `unknown error: ${S.debug(error)}`;
			}
		};

		const defaultRuntimeErrorFormatter = error => {
			switch (error?.type) {
				case 'reference': return `"${error.name}" not found`;
				case 'property': return `"${error.property}" property not exists`;
				case 'range': return `${error.index} is out of range`;
				case 'type': return `'${error.expected}' expected, but ${S.debug(error.actual)} found`;
				case 'security': return `<${error.target}> is not allowed for security reasons`;
				default: return `unknown error: ${S.debug(error)}`;
			}
		};

		return {
			NUMBER,
			BOOLEAN,
			ANY,
			Lexer,
			parser,
			parse,
			build,
			compile,
			expect,
			run,
			interpret,
			defaultCompileErrorFormatter,
			defaultRuntimeErrorFormatter,
		};
	})();

	const P = (() => {
		const RE_INTEGER = /^[+\-]?\d+$/;
		const RE_NUMBER = /^[+\-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+\-]?\d+)?$/i;

		const formatError = (source, expected) => ({ type: 'format', source, expected });
		const jsonError = (source, inner) => ({ type: 'json', source, inner });
		const expressionError = (source, cause) => ({ type: 'expression', source, cause });
		const validationError = (source, cause) => ({ type: 'validation', source, cause });

		const succeed = value => () => R.ok(value);
		const fail = error => () => R.err(error);
		const andThen = (parser, fn) => s => R.andThen(parser(s), value => fn(value)(s));
		const orElse = (parser, fn) => s => R.orElse(parser(s), error => fn(error)(s));
		const map = (parser, fn) => s => R.map(parser(s), fn);
		const mapError = (parser, fn) => s => R.mapErr(parser(s), fn);
		const wrapError = (parser, fn) => s => mapError(parser, error => fn(s, error))(s);
		const fromResult = result => R.match(result, succeed, fail);

		const withDefault = (parser, value) => orElse(map(empty, () => value), () => parser);
		const validate = (parser, validator) => andThen(parser, value => wrapError(fromResult(validator(value)), validationError));

		const empty = s => s === "" ? R.ok(undefined) : R.err(formatError(s, "empty"));
		const integer = s => RE_INTEGER.test(s) ? R.ok(Number.parseInt(s, 10)) : R.err(formatError(s, "integer"));
		const number = s => RE_NUMBER.test(s) ? R.ok(Number.parseFloat(s)) : R.err(formatError(s, "number"));
		const string = s => R.ok(s);
		const boolean = s => s === 'true' ? R.ok(true) : s === 'false' ? R.ok(false) : R.err(formatError(s, "boolean"));
		const custom = fn => s => R.mapErr(fn(s), expected => formatError(s, expected));

		const json = s => R.mapErr(R.attempt(() => JSON.parse(s)), e => jsonError(s, e));
		const array = parser => andThen(json, value => s =>
			Array.isArray(value) ? R.allL(value.map(x => () => parser(x))) : R.err(formatError(s, "array"))
		);
		const struct = parsers => andThen(json, value => s =>
			typeof value === 'object' && value !== null && !Array.isArray(value)
				? R.map(entries(parsers)(value), Object.fromEntries)
				: R.err(formatError(s, "struct"))
		);
		const entries = parsers => object => R.allL(parsers.map(parser => () => parser(object)));
		const entry = (key, parser) => object => map(parser, value => [key, value])(object[key] ?? "");

		const expression = (type, errorFormatter) => s => R.match(
			E.compile(type, s),
			evaluator => R.ok(env => E.run(evaluator, env, errorFormatter)),
			cause => R.err(expressionError(s, cause)),
		);

		const make = archetype => {
			if (typeof archetype === 'function') {
				return archetype;
			} else if (typeof archetype === 'object' && archetype !== null) {
				if (Array.isArray(archetype)) {
					if (archetype.length === 1) {
						return array(make(archetype[0]));
					} else {
						return panic(`archetype array must be a singleton: ${S.debug(archetype)}`);
					}
				} else {
					return struct(Object.entries(archetype).map(([key, value]) => entry(key, make(value))));
				}
			} else {
				return panic(`invalid archetype item: ${S.debug(archetype)}`);
			}
		};

		const parse = (s, parser, errorFormatter = defaultErrorFormatter) => R.expect(parser(s), errorFormatter);

		const parseAll = (args, parsers, errorFormatter) => {
			return Object.fromEntries(Object.entries(parsers).map(([key, parser]) => {
				return [key, parse(args[key], parser, errorFormatter)];
			}));
		};

		const makeDefaultErrorFormatter = (validationErrorFormatter) => error => {
			const dots = s => S.ellipsis(s, 32);
			switch (error?.type) {
				case 'format': return `'${error.expected}' expected, but "${dots(error.source)}" found`;
				case 'json': return `failed to parse JSON; ${error.inner.message}`;
				case 'expression': return `failed to parse expression; ${E.defaultCompileErrorFormatter(error.cause)}`;
				case 'validation': return validationErrorFormatter(error.cause);
				default: return `unknown error: ${S.debug(error)}`;
			}
		};

		const simpleErrorFormatter = error => typeof error === 'string' ? error : S.debug(error);

		const defaultErrorFormatter = makeDefaultErrorFormatter(simpleErrorFormatter);

		return {
			succeed,
			fail,
			andThen,
			orElse,
			map,
			mapError,
			withDefault,
			validate,
			empty,
			integer,
			number,
			string,
			boolean,
			custom,
			json,
			array,
			struct,
			entry,
			expression,
			make,
			parse,
			parseAll,
			makeDefaultErrorFormatter,
			defaultErrorFormatter,
		};
	})();

	const N = (() => {
		const RE_SPACING = /^[ \r\n]*/;
		const RE_SPACES = /^[ \r\n]+/;
		const RE_NATURAL = /^\d+/;
		const RE_INTEGER = /^[+\-]?\d+/;
		const RE_NUMBER = /^[+\-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+\-]?\d+)?/i;
		const RE_BOOLEAN = /^(?:true|false)\b/;
		const RE_TEXT = /^(?:'(?:[^'`]|`.)*'|"(?:[^"`]|`.)*")/u;

		const symbolError = (source, position, symbol) => ({ type: 'symbol', source, position, symbol });
		const regexpError = (source, position, name, regexp) => ({ type: 'regexp', source, position, name, regexp });
		const expressionError = (source, position, cause) => ({ type: 'expression', source, position, cause });

		const { succeed, fail } = G;
		const map = (parser, fn) => G.memo(G.map(parser, fn));
		const mapError = (parser, fn) => G.memo(G.mapError(parser, fn));
		const seqOf = parsers => G.memo(G.seqOf(parsers));
		const oneOf = parsers => G.memo(G.oneOf(parsers));
		const validate = (parser, validator) => G.memo(G.validate(parser, validator));

		const symbol = symbol => G.memo(G.token((source, position) => {
			return source.startsWith(symbol, position)
				? R.ok([symbol, position + symbol.length])
				: R.err(symbolError(source, position, symbol));
		}));

		const regexp = (name, re, fn) => G.memo(G.token((source, position) => {
			const slice = source.slice(position);
			const match = slice.match(re);
			if (match !== null && match.index === 0) {
				const token = match[0];
				const value = fn !== undefined ? fn(...match) : token;
				return R.ok([value, position + token.length]);
			} else {
				return R.err(regexpError(source, position, name, re));
			}
		}));

		const expression = (type, errorFormatter) => {
			const pipe = (a, fn) => fn(a);
			const parse = G.make(E.parser);
			const build = node => E.build(type, node);
			const make = evaluator => env => E.run(evaluator, env, errorFormatter);
			return G.memo(G.token((source, position) =>
				R.mapBoth(
					parse(source, position),
					([node, next]) => [pipe(build(node), make), next],
					cause => expressionError(source, position, cause),
				)
			));
		};

		const spacing = regexp("spacing", RE_SPACING);
		const spaces = regexp("spaces", RE_SPACES);
		const natural = regexp("natural", RE_NATURAL, s => Number.parseInt(s, 10));
		const integer = regexp("integer", RE_INTEGER, s => Number.parseInt(s, 10));
		const number = regexp("number", RE_NUMBER, s => Number.parseFloat(s));
		const boolean = regexp("boolean", RE_BOOLEAN, s => s === 'true');
		const text = regexp("text", RE_TEXT, value => value.slice(1, -1).replace(/`(.)/gu, "$1"));

		const between = (parser, start, end) => map(G.seqOf([start, parser, end]), value => value[1]);
		const margin = parser => between(parser, spacing, spacing);
		const group = (parser, begin, end) => between(margin(parser), begin, end);
		const parens = parser => group(parser, symbol("("), symbol(")"));
		const braces = parser => group(parser, symbol("{"), symbol("}"));
		const brackets = parser => group(parser, symbol("["), symbol("]"));
		const endWith = parser => G.andThen(parser, value => G.map(G.eoi(), () => value));

		const withDefault = (parser, value) => map(G.optional(parser), option => O.withDefault(option, value));
		const chain = (item, delimiter) => withDefault(chain1(item, delimiter), []);
		const chain1 = (item, delimiter) => flatten(G.seqOf([item, G.many(G.seqOf([delimiter, item]))]));
		const flatten = parser => map(parser, ([first, rest]) => [first, ...rest.map(([, item]) => item)]);
		const join = (items, delimiter) => map(delimit(items, delimiter), array => array.filter((_, i) => i % 2 === 0));
		const delimit = (items, delimiter) => G.seqOf(items.flatMap((item, i) => i === 0 ? [item] : [delimiter, item]));
		const list = parser => chain(parser, spaces);
		const tuple = parsers => join(parsers, spaces);

		const make = parser => G.mk(parser);
		const parse = (source, parser, errorFormatter = defaultErrorFormatter) => G.parse(source, parser, errorFormatter);

		const defaultTokenErrorFormatter = error => {
			const dots = s => S.ellipsis(s, 16);
			const rest = ({ source: s, position: i }) => s.length === i ? "no more characters" : `"${dots(s.slice(i))}"`;
			switch (error?.type) {
				case 'symbol': return `'${error.symbol}' expected, but ${rest(error)} found`;
				case 'regexp': return `'${error.name}' expected, but ${rest(error)} found`;
				case 'expression': return E.defaultCompileErrorFormatter(error.cause);
				default: return `unknown error: ${S.debug(error)}`;
			}
		};

		const makeDefaultErrorFormatter = validationErrorFormatter =>
			G.makeDefaultErrorFormatter(defaultTokenErrorFormatter, validationErrorFormatter);

		const simpleErrorFormatter = error => typeof error === 'string' ? error : S.debug(error);

		const defaultErrorFormatter = makeDefaultErrorFormatter(simpleErrorFormatter);

		return {
			succeed,
			fail,
			map,
			mapError,
			seqOf,
			oneOf,
			validate,
			symbol,
			regexp,
			expression,
			spacing,
			spaces,
			natural,
			integer,
			number,
			boolean,
			text,
			margin,
			group,
			parens,
			braces,
			brackets,
			endWith,
			withDefault,
			chain,
			chain1,
			join,
			list,
			tuple,
			make,
			parse,
			defaultTokenErrorFormatter,
			makeDefaultErrorFormatter,
			defaultErrorFormatter,
		};
	})();

	const M = (() => {
		const notationError = (expected, name, value) => ({ type: 'notation', expected, name, value });
		const attributeError = (name, source, cause) => ({ type: 'attribute', name, source, cause });

		const flag = name => meta => {
			const v = meta[name];
			switch (v) {
				case undefined: return R.ok(O.some(false));
				case true: return R.ok(O.some(true));
				default: return R.err(notationError('flag', name, v));
			}
		};

		const attr = (name, parser) => meta => {
			const v = meta[name];
			if (typeof v === 'string') {
				return R.mapErr(R.map(parser(v), O.some), cause => attributeError(name, v, cause));
			} else if (v === undefined) {
				return R.ok(O.none());
			} else {
				return R.err(notationError('attr', name, v));
			}
		};
		const attrN = (name, parser) => attr(name, N.make(N.endWith(N.margin(parser))));

		const succeed = value => () => R.ok(O.some(value));
		const miss = () => () => R.ok(O.none());
		const fail = error => () => R.err(error);
		const andThen = (parser, fn) => data => R.andThen(parser(data), option => O.match(option, fn, miss)(data));
		const orElse = (parser, fn) => data => R.andThen(parser(data), option => O.match(option, succeed, fn)(data));
		const map = (parser, fn) => andThen(parser, value => succeed(fn(value)));
		const mapError = (parser, fn) => data => R.mapErr(parser(data), fn);
		const withDefault = (parser, value) => orElse(parser, () => succeed(value));
		const oneOf = parsers => parsers.reduceRight((acc, x) => orElse(x, () => acc), miss());

		const make = archetype => {
			const arrayOf = parsers => parsers.reduce((xs, x) => andThen(xs, xs => map(x, x => [...xs, x])), succeed([]));
			const structOf = parsers => map(arrayOf(parsers.map(entry)), Object.fromEntries);
			const entry = ([key, parser]) => map(parser, value => [key, value]);

			if (typeof archetype === 'function') {
				return archetype;
			} else if (typeof archetype === 'object' && archetype !== null) {
				if (Array.isArray(archetype)) {
					return arrayOf(archetype.map(make));
				} else {
					return structOf(Object.entries(archetype).map(([key, value]) => [key, make(value)]));
				}
			} else {
				return () => R.ok(R.some(archetype));
			}
		};

		const parse = (meta, parser, errorFormatter = defaultErrorFormatter) =>
			R.expect(R.map(parser(meta), value => O.withDefault(value, undefined)), errorFormatter);

		const meta = (parser, errorFormatter) => U.memoW(meta => parse(meta, parser, errorFormatter));

		const makeDefaultErrorFormatter = attributeErrorFormatter => error => {
			switch (error?.type) {
				case 'notation':
					switch (error.expected) {
						case 'flag': return `'${error.name}' metadata does not require value`;
						case 'attr': return `'${error.name}' metadata requires value`;
						default: return `unknown metadata type: ${error.expected}`;
					}
				case 'attribute':
					const message = attributeErrorFormatter(error.cause);
					return `failed to parse '${error.name}' metadata value; ${message}`;
				default: return `unknown error: ${S.debug(error)}`;
			}
		};

		const defaultErrorFormatter = makeDefaultErrorFormatter(N.defaultErrorFormatter);

		return {
			flag,
			attr,
			attrN,
			succeed,
			miss,
			fail,
			andThen,
			orElse,
			map,
			mapError,
			withDefault,
			oneOf,
			make,
			parse,
			meta,
			makeDefaultErrorFormatter,
			defaultErrorFormatter,
		};
	})();

	const Z = (() => {
		const pluginName = () => document.currentScript?.src.match(/\/([^\/]*)\.js$/)?.[1];

		const redef = (target, define) => {
			const table = {};
			const base = this_ => new Proxy(table, {
				get(target, p, receiver) {
					const value = Reflect.get(target, p, receiver);
					return typeof value !== 'function' ? value : value.bind(this_);
				},
			});

			const definitions = define(base);
			const proto = Object.getPrototypeOf(target);
			for (const [key, value] of Object.entries(definitions)) {
				if (typeof value === 'function') {
					if (target.hasOwnProperty(key)) {
						table[key] = target[key];
					} else if (key in proto) {
						table[key] = function () { return proto[key].apply(this, arguments); };
					}
				}
				target[key] = value;
			}
		};

		const extProp = (defaultValue, nonWeak = false) =>
			nonWeak ? propWithMap(defaultValue) : propWithWeakMap(defaultValue);

		const propWithMap = defaultValue => {
			const store = new Map();
			const get = key => store.has(key) ? store.get(key) : defaultValue;
			const set = (key, value) => void store.set(key, value);
			const delete_ = key => void store.delete(key);
			const clear = () => store.clear();
			return { get, set, delete: delete_, clear };
		};

		const propWithWeakMap = defaultValue => {
			const store = new WeakMap();
			const get = key => store.has(key) ? store.get(key) : defaultValue;
			const set = (key, value) => void store.set(key, value);
			const delete_ = key => void store.delete(key);
			return { get, set, delete: delete_ };
		};

		const extend = (target, name, prop) => {
			const { get, set } = prop;
			Object.defineProperty(target, name, {
				get() { return get(this); },
				set(value) { set(this, value); },
				configurable: true,
			});
		};

		const swapper = key => (owner, value, block) => {
			const current = owner[key];
			return enclose(
				() => owner[key] = value,
				() => owner[key] = current,
				block,
			);
		};

		const context = defaultValue => {
			const { get: getContext, set: setContext } = propWithWeakMap(O.none());
			const enter = (owner, value, block) => {
				const current = getContext(owner);
				return enclose(
					() => setContext(owner, O.some(value)),
					() => setContext(owner, current),
					block,
				);
			};
			const value = owner => O.withDefault(getContext(owner), defaultValue);
			const exists = owner => O.isSome(getContext(owner));
			return { enter, value, exists };
		};

		const defer = cleanup => block => {
			try { return block(); } finally { cleanup(); }
		};

		const enclose = (begin, end, block) => {
			begin();
			return defer(end)(block);
		};

		return { pluginName, redef, extProp, extend, swapper, context, defer, enclose };
	})();

	globalThis.Fs = { O, R, L, S, U, G, E, P, N, M, Z };
};