diff --git a/e2e/rescript-v10-JSX4/bsconfig.json b/e2e/rescript-v10-JSX4/bsconfig.json index 463aad2fc..c7fd01582 100644 --- a/e2e/rescript-v10-JSX4/bsconfig.json +++ b/e2e/rescript-v10-JSX4/bsconfig.json @@ -1,14 +1,18 @@ { "name": "styled-ppx-demo-rescript-v10-jsx4", - "jsx": { "version": 4 }, + "jsx": { "version": 4, "mode": "classic" }, "bsc-flags": [ "-bs-super-errors" ], - "sources": { + "sources": [{ "dir": "src", - "subdirs": true, + "subdirs": false, "type": "dev" - }, + }, { + "dir": "demo", + "subdirs": false, + "type": "dev" + }], "package-specs": [ { "module": "commonjs", diff --git a/e2e/rescript-v10-JSX4/demo/bundle.js b/e2e/rescript-v10-JSX4/demo/bundle.js new file mode 100644 index 000000000..e64a588ec --- /dev/null +++ b/e2e/rescript-v10-JSX4/demo/bundle.js @@ -0,0 +1,37777 @@ +(() => { + var __commonJS = (callback, module) => () => { + if (!module) { + module = {exports: {}}; + callback(module.exports, module); + } + return module.exports; + }; + + // node_modules/rescript/lib/js/caml_option.js + var require_caml_option = __commonJS((exports) => { + "use strict"; + function isNested(x) { + return x.BS_PRIVATE_NESTED_SOME_NONE !== void 0; + } + function some(x) { + if (x === void 0) { + return { + BS_PRIVATE_NESTED_SOME_NONE: 0 + }; + } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) { + return { + BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0 + }; + } else { + return x; + } + } + function nullable_to_opt(x) { + if (x == null) { + return; + } else { + return some(x); + } + } + function undefined_to_opt(x) { + if (x === void 0) { + return; + } else { + return some(x); + } + } + function null_to_opt(x) { + if (x === null) { + return; + } else { + return some(x); + } + } + function valFromOption(x) { + if (!(x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0)) { + return x; + } + var depth = x.BS_PRIVATE_NESTED_SOME_NONE; + if (depth === 0) { + return; + } else { + return { + BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0 + }; + } + } + function option_get(x) { + if (x === void 0) { + return; + } else { + return valFromOption(x); + } + } + function option_unwrap(x) { + if (x !== void 0) { + return x.VAL; + } else { + return x; + } + } + exports.nullable_to_opt = nullable_to_opt; + exports.undefined_to_opt = undefined_to_opt; + exports.null_to_opt = null_to_opt; + exports.valFromOption = valFromOption; + exports.some = some; + exports.isNested = isNested; + exports.option_get = option_get; + exports.option_unwrap = option_unwrap; + }); + + // node_modules/rescript/lib/js/js_dict.js + var require_js_dict = __commonJS((exports) => { + "use strict"; + var Caml_option = require_caml_option(); + function get(dict, k) { + if (k in dict) { + return Caml_option.some(dict[k]); + } + } + var unsafeDeleteKey = function(dict, key) { + delete dict[key]; + }; + function entries(dict) { + var keys = Object.keys(dict); + var l = keys.length; + var values2 = new Array(l); + for (var i = 0; i < l; ++i) { + var key = keys[i]; + values2[i] = [ + key, + dict[key] + ]; + } + return values2; + } + function values(dict) { + var keys = Object.keys(dict); + var l = keys.length; + var values$1 = new Array(l); + for (var i = 0; i < l; ++i) { + values$1[i] = dict[keys[i]]; + } + return values$1; + } + function fromList(entries2) { + var dict = {}; + var _param = entries2; + while (true) { + var param = _param; + if (!param) { + return dict; + } + var match = param.hd; + dict[match[0]] = match[1]; + _param = param.tl; + continue; + } + ; + } + function fromArray(entries2) { + var dict = {}; + var l = entries2.length; + for (var i = 0; i < l; ++i) { + var match = entries2[i]; + dict[match[0]] = match[1]; + } + return dict; + } + function map(f, source) { + var target = {}; + var keys = Object.keys(source); + var l = keys.length; + for (var i = 0; i < l; ++i) { + var key = keys[i]; + target[key] = f(source[key]); + } + return target; + } + exports.get = get; + exports.unsafeDeleteKey = unsafeDeleteKey; + exports.entries = entries; + exports.values = values; + exports.fromList = fromList; + exports.fromArray = fromArray; + exports.map = map; + }); + + // node_modules/rescript/lib/js/caml.js + var require_caml = __commonJS((exports) => { + "use strict"; + function int_compare(x, y) { + if (x < y) { + return -1; + } else if (x === y) { + return 0; + } else { + return 1; + } + } + function bool_compare(x, y) { + if (x) { + if (y) { + return 0; + } else { + return 1; + } + } else if (y) { + return -1; + } else { + return 0; + } + } + function float_compare(x, y) { + if (x === y) { + return 0; + } else if (x < y) { + return -1; + } else if (x > y || x === x) { + return 1; + } else if (y === y) { + return -1; + } else { + return 0; + } + } + function string_compare(s1, s2) { + if (s1 === s2) { + return 0; + } else if (s1 < s2) { + return -1; + } else { + return 1; + } + } + function bool_min(x, y) { + if (x) { + return y; + } else { + return x; + } + } + function int_min(x, y) { + if (x < y) { + return x; + } else { + return y; + } + } + function float_min(x, y) { + if (x < y) { + return x; + } else { + return y; + } + } + function string_min(x, y) { + if (x < y) { + return x; + } else { + return y; + } + } + function bool_max(x, y) { + if (x) { + return x; + } else { + return y; + } + } + function int_max(x, y) { + if (x > y) { + return x; + } else { + return y; + } + } + function float_max(x, y) { + if (x > y) { + return x; + } else { + return y; + } + } + function string_max(x, y) { + if (x > y) { + return x; + } else { + return y; + } + } + function i64_eq(x, y) { + if (x[1] === y[1]) { + return x[0] === y[0]; + } else { + return false; + } + } + function i64_ge(param, param$1) { + var other_hi = param$1[0]; + var hi = param[0]; + if (hi > other_hi) { + return true; + } else if (hi < other_hi) { + return false; + } else { + return param[1] >= param$1[1]; + } + } + function i64_neq(x, y) { + return !i64_eq(x, y); + } + function i64_lt(x, y) { + return !i64_ge(x, y); + } + function i64_gt(x, y) { + if (x[0] > y[0]) { + return true; + } else if (x[0] < y[0]) { + return false; + } else { + return x[1] > y[1]; + } + } + function i64_le(x, y) { + return !i64_gt(x, y); + } + function i64_min(x, y) { + if (i64_ge(x, y)) { + return y; + } else { + return x; + } + } + function i64_max(x, y) { + if (i64_gt(x, y)) { + return x; + } else { + return y; + } + } + exports.int_compare = int_compare; + exports.bool_compare = bool_compare; + exports.float_compare = float_compare; + exports.string_compare = string_compare; + exports.bool_min = bool_min; + exports.int_min = int_min; + exports.float_min = float_min; + exports.string_min = string_min; + exports.bool_max = bool_max; + exports.int_max = int_max; + exports.float_max = float_max; + exports.string_max = string_max; + exports.i64_eq = i64_eq; + exports.i64_neq = i64_neq; + exports.i64_lt = i64_lt; + exports.i64_gt = i64_gt; + exports.i64_le = i64_le; + exports.i64_ge = i64_ge; + exports.i64_min = i64_min; + exports.i64_max = i64_max; + }); + + // node_modules/rescript/lib/js/char.js + var require_char = __commonJS((exports) => { + "use strict"; + var Bytes = require_bytes(); + function chr(n) { + if (n < 0 || n > 255) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "Char.chr", + Error: new Error() + }; + } + return n; + } + function escaped(c) { + var exit = 0; + if (c >= 40) { + if (c === 92) { + return "\\\\"; + } + exit = c >= 127 ? 1 : 2; + } else if (c >= 32) { + if (c >= 39) { + return "\\'"; + } + exit = 2; + } else if (c >= 14) { + exit = 1; + } else { + switch (c) { + case 8: + return "\\b"; + case 9: + return "\\t"; + case 10: + return "\\n"; + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 11: + case 12: + exit = 1; + break; + case 13: + return "\\r"; + } + } + switch (exit) { + case 1: + var s = [ + 0, + 0, + 0, + 0 + ]; + s[0] = 92; + s[1] = 48 + (c / 100 | 0) | 0; + s[2] = 48 + (c / 10 | 0) % 10 | 0; + s[3] = 48 + c % 10 | 0; + return Bytes.to_string(s); + case 2: + var s$1 = [0]; + s$1[0] = c; + return Bytes.to_string(s$1); + } + } + function lowercase(c) { + if (c >= 65 && c <= 90 || c >= 192 && c <= 214 || c >= 216 && c <= 222) { + return c + 32 | 0; + } else { + return c; + } + } + function uppercase(c) { + if (c >= 97 && c <= 122 || c >= 224 && c <= 246 || c >= 248 && c <= 254) { + return c - 32 | 0; + } else { + return c; + } + } + function lowercase_ascii(c) { + if (c >= 65 && c <= 90) { + return c + 32 | 0; + } else { + return c; + } + } + function uppercase_ascii(c) { + if (c >= 97 && c <= 122) { + return c - 32 | 0; + } else { + return c; + } + } + function compare(c1, c2) { + return c1 - c2 | 0; + } + function equal(c1, c2) { + return (c1 - c2 | 0) === 0; + } + exports.chr = chr; + exports.escaped = escaped; + exports.lowercase = lowercase; + exports.uppercase = uppercase; + exports.lowercase_ascii = lowercase_ascii; + exports.uppercase_ascii = uppercase_ascii; + exports.compare = compare; + exports.equal = equal; + }); + + // node_modules/rescript/lib/js/caml_array.js + var require_caml_array = __commonJS((exports) => { + "use strict"; + function sub(x, offset, len2) { + var result = new Array(len2); + var j = 0; + var i = offset; + while (j < len2) { + result[j] = x[i]; + j = j + 1 | 0; + i = i + 1 | 0; + } + ; + return result; + } + function len(_acc, _l) { + while (true) { + var l = _l; + var acc = _acc; + if (!l) { + return acc; + } + _l = l.tl; + _acc = l.hd.length + acc | 0; + continue; + } + ; + } + function fill(arr, _i, _l) { + while (true) { + var l = _l; + var i = _i; + if (!l) { + return; + } + var x = l.hd; + var l$1 = x.length; + var k = i; + var j = 0; + while (j < l$1) { + arr[k] = x[j]; + k = k + 1 | 0; + j = j + 1 | 0; + } + ; + _l = l.tl; + _i = k; + continue; + } + ; + } + function concat(l) { + var v = len(0, l); + var result = new Array(v); + fill(result, 0, l); + return result; + } + function set(xs, index, newval) { + if (index < 0 || index >= xs.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "index out of bounds", + Error: new Error() + }; + } + xs[index] = newval; + } + function get(xs, index) { + if (index < 0 || index >= xs.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "index out of bounds", + Error: new Error() + }; + } + return xs[index]; + } + function make(len2, init) { + var b = new Array(len2); + for (var i = 0; i < len2; ++i) { + b[i] = init; + } + return b; + } + function make_float(len2) { + var b = new Array(len2); + for (var i = 0; i < len2; ++i) { + b[i] = 0; + } + return b; + } + function blit(a1, i1, a2, i2, len2) { + if (i2 <= i1) { + for (var j = 0; j < len2; ++j) { + a2[j + i2 | 0] = a1[j + i1 | 0]; + } + return; + } + for (var j$1 = len2 - 1 | 0; j$1 >= 0; --j$1) { + a2[j$1 + i2 | 0] = a1[j$1 + i1 | 0]; + } + } + function dup(prim) { + return prim.slice(0); + } + exports.dup = dup; + exports.sub = sub; + exports.concat = concat; + exports.make = make; + exports.make_float = make_float; + exports.blit = blit; + exports.get = get; + exports.set = set; + }); + + // node_modules/rescript/lib/js/curry.js + var require_curry = __commonJS((exports) => { + "use strict"; + var Caml_array = require_caml_array(); + function app(_f, _args) { + while (true) { + var args = _args; + var f = _f; + var init_arity = f.length; + var arity = init_arity === 0 ? 1 : init_arity; + var len = args.length; + var d = arity - len | 0; + if (d === 0) { + return f.apply(null, args); + } + if (d >= 0) { + return function(f2, args2) { + return function(x) { + return app(f2, args2.concat([x])); + }; + }(f, args); + } + _args = Caml_array.sub(args, arity, -d | 0); + _f = f.apply(null, Caml_array.sub(args, 0, arity)); + continue; + } + ; + } + function _1(o, a0) { + var arity = o.length; + if (arity === 1) { + return o(a0); + } else { + switch (arity) { + case 1: + return o(a0); + case 2: + return function(param) { + return o(a0, param); + }; + case 3: + return function(param, param$1) { + return o(a0, param, param$1); + }; + case 4: + return function(param, param$1, param$2) { + return o(a0, param, param$1, param$2); + }; + case 5: + return function(param, param$1, param$2, param$3) { + return o(a0, param, param$1, param$2, param$3); + }; + case 6: + return function(param, param$1, param$2, param$3, param$4) { + return o(a0, param, param$1, param$2, param$3, param$4); + }; + case 7: + return function(param, param$1, param$2, param$3, param$4, param$5) { + return o(a0, param, param$1, param$2, param$3, param$4, param$5); + }; + default: + return app(o, [a0]); + } + } + } + function __1(o) { + var arity = o.length; + if (arity === 1) { + return o; + } else { + return function(a0) { + return _1(o, a0); + }; + } + } + function _2(o, a0, a1) { + var arity = o.length; + if (arity === 2) { + return o(a0, a1); + } else { + switch (arity) { + case 1: + return app(o(a0), [a1]); + case 2: + return o(a0, a1); + case 3: + return function(param) { + return o(a0, a1, param); + }; + case 4: + return function(param, param$1) { + return o(a0, a1, param, param$1); + }; + case 5: + return function(param, param$1, param$2) { + return o(a0, a1, param, param$1, param$2); + }; + case 6: + return function(param, param$1, param$2, param$3) { + return o(a0, a1, param, param$1, param$2, param$3); + }; + case 7: + return function(param, param$1, param$2, param$3, param$4) { + return o(a0, a1, param, param$1, param$2, param$3, param$4); + }; + default: + return app(o, [ + a0, + a1 + ]); + } + } + } + function __2(o) { + var arity = o.length; + if (arity === 2) { + return o; + } else { + return function(a0, a1) { + return _2(o, a0, a1); + }; + } + } + function _3(o, a0, a1, a2) { + var arity = o.length; + if (arity === 3) { + return o(a0, a1, a2); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2 + ]); + case 2: + return app(o(a0, a1), [a2]); + case 3: + return o(a0, a1, a2); + case 4: + return function(param) { + return o(a0, a1, a2, param); + }; + case 5: + return function(param, param$1) { + return o(a0, a1, a2, param, param$1); + }; + case 6: + return function(param, param$1, param$2) { + return o(a0, a1, a2, param, param$1, param$2); + }; + case 7: + return function(param, param$1, param$2, param$3) { + return o(a0, a1, a2, param, param$1, param$2, param$3); + }; + default: + return app(o, [ + a0, + a1, + a2 + ]); + } + } + } + function __3(o) { + var arity = o.length; + if (arity === 3) { + return o; + } else { + return function(a0, a1, a2) { + return _3(o, a0, a1, a2); + }; + } + } + function _4(o, a0, a1, a2, a3) { + var arity = o.length; + if (arity === 4) { + return o(a0, a1, a2, a3); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2, + a3 + ]); + case 2: + return app(o(a0, a1), [ + a2, + a3 + ]); + case 3: + return app(o(a0, a1, a2), [a3]); + case 4: + return o(a0, a1, a2, a3); + case 5: + return function(param) { + return o(a0, a1, a2, a3, param); + }; + case 6: + return function(param, param$1) { + return o(a0, a1, a2, a3, param, param$1); + }; + case 7: + return function(param, param$1, param$2) { + return o(a0, a1, a2, a3, param, param$1, param$2); + }; + default: + return app(o, [ + a0, + a1, + a2, + a3 + ]); + } + } + } + function __4(o) { + var arity = o.length; + if (arity === 4) { + return o; + } else { + return function(a0, a1, a2, a3) { + return _4(o, a0, a1, a2, a3); + }; + } + } + function _5(o, a0, a1, a2, a3, a4) { + var arity = o.length; + if (arity === 5) { + return o(a0, a1, a2, a3, a4); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2, + a3, + a4 + ]); + case 2: + return app(o(a0, a1), [ + a2, + a3, + a4 + ]); + case 3: + return app(o(a0, a1, a2), [ + a3, + a4 + ]); + case 4: + return app(o(a0, a1, a2, a3), [a4]); + case 5: + return o(a0, a1, a2, a3, a4); + case 6: + return function(param) { + return o(a0, a1, a2, a3, a4, param); + }; + case 7: + return function(param, param$1) { + return o(a0, a1, a2, a3, a4, param, param$1); + }; + default: + return app(o, [ + a0, + a1, + a2, + a3, + a4 + ]); + } + } + } + function __5(o) { + var arity = o.length; + if (arity === 5) { + return o; + } else { + return function(a0, a1, a2, a3, a4) { + return _5(o, a0, a1, a2, a3, a4); + }; + } + } + function _6(o, a0, a1, a2, a3, a4, a5) { + var arity = o.length; + if (arity === 6) { + return o(a0, a1, a2, a3, a4, a5); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2, + a3, + a4, + a5 + ]); + case 2: + return app(o(a0, a1), [ + a2, + a3, + a4, + a5 + ]); + case 3: + return app(o(a0, a1, a2), [ + a3, + a4, + a5 + ]); + case 4: + return app(o(a0, a1, a2, a3), [ + a4, + a5 + ]); + case 5: + return app(o(a0, a1, a2, a3, a4), [a5]); + case 6: + return o(a0, a1, a2, a3, a4, a5); + case 7: + return function(param) { + return o(a0, a1, a2, a3, a4, a5, param); + }; + default: + return app(o, [ + a0, + a1, + a2, + a3, + a4, + a5 + ]); + } + } + } + function __6(o) { + var arity = o.length; + if (arity === 6) { + return o; + } else { + return function(a0, a1, a2, a3, a4, a5) { + return _6(o, a0, a1, a2, a3, a4, a5); + }; + } + } + function _7(o, a0, a1, a2, a3, a4, a5, a6) { + var arity = o.length; + if (arity === 7) { + return o(a0, a1, a2, a3, a4, a5, a6); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2, + a3, + a4, + a5, + a6 + ]); + case 2: + return app(o(a0, a1), [ + a2, + a3, + a4, + a5, + a6 + ]); + case 3: + return app(o(a0, a1, a2), [ + a3, + a4, + a5, + a6 + ]); + case 4: + return app(o(a0, a1, a2, a3), [ + a4, + a5, + a6 + ]); + case 5: + return app(o(a0, a1, a2, a3, a4), [ + a5, + a6 + ]); + case 6: + return app(o(a0, a1, a2, a3, a4, a5), [a6]); + case 7: + return o(a0, a1, a2, a3, a4, a5, a6); + default: + return app(o, [ + a0, + a1, + a2, + a3, + a4, + a5, + a6 + ]); + } + } + } + function __7(o) { + var arity = o.length; + if (arity === 7) { + return o; + } else { + return function(a0, a1, a2, a3, a4, a5, a6) { + return _7(o, a0, a1, a2, a3, a4, a5, a6); + }; + } + } + function _8(o, a0, a1, a2, a3, a4, a5, a6, a7) { + var arity = o.length; + if (arity === 8) { + return o(a0, a1, a2, a3, a4, a5, a6, a7); + } else { + switch (arity) { + case 1: + return app(o(a0), [ + a1, + a2, + a3, + a4, + a5, + a6, + a7 + ]); + case 2: + return app(o(a0, a1), [ + a2, + a3, + a4, + a5, + a6, + a7 + ]); + case 3: + return app(o(a0, a1, a2), [ + a3, + a4, + a5, + a6, + a7 + ]); + case 4: + return app(o(a0, a1, a2, a3), [ + a4, + a5, + a6, + a7 + ]); + case 5: + return app(o(a0, a1, a2, a3, a4), [ + a5, + a6, + a7 + ]); + case 6: + return app(o(a0, a1, a2, a3, a4, a5), [ + a6, + a7 + ]); + case 7: + return app(o(a0, a1, a2, a3, a4, a5, a6), [a7]); + default: + return app(o, [ + a0, + a1, + a2, + a3, + a4, + a5, + a6, + a7 + ]); + } + } + } + function __8(o) { + var arity = o.length; + if (arity === 8) { + return o; + } else { + return function(a0, a1, a2, a3, a4, a5, a6, a7) { + return _8(o, a0, a1, a2, a3, a4, a5, a6, a7); + }; + } + } + exports.app = app; + exports._1 = _1; + exports.__1 = __1; + exports._2 = _2; + exports.__2 = __2; + exports._3 = _3; + exports.__3 = __3; + exports._4 = _4; + exports.__4 = __4; + exports._5 = _5; + exports.__5 = __5; + exports._6 = _6; + exports.__6 = __6; + exports._7 = _7; + exports.__7 = __7; + exports._8 = _8; + exports.__8 = __8; + }); + + // node_modules/rescript/lib/js/caml_bytes.js + var require_caml_bytes = __commonJS((exports) => { + "use strict"; + function set(s, i, ch) { + if (i < 0 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "index out of bounds", + Error: new Error() + }; + } + s[i] = ch; + } + function get(s, i) { + if (i < 0 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "index out of bounds", + Error: new Error() + }; + } + return s[i]; + } + function create(len) { + if (len < 0) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.create", + Error: new Error() + }; + } + var result = new Array(len); + for (var i = 0; i < len; ++i) { + result[i] = 0; + } + return result; + } + function bytes_compare_aux(s1, s2, _off, len, def) { + while (true) { + var off = _off; + if (off >= len) { + return def; + } + var a = s1[off]; + var b = s2[off]; + if (a > b) { + return 1; + } + if (a < b) { + return -1; + } + _off = off + 1 | 0; + continue; + } + ; + } + function bytes_compare(s1, s2) { + var len1 = s1.length; + var len2 = s2.length; + if (len1 === len2) { + return bytes_compare_aux(s1, s2, 0, len1, 0); + } else if (len1 < len2) { + return bytes_compare_aux(s1, s2, 0, len1, -1); + } else { + return bytes_compare_aux(s1, s2, 0, len2, 1); + } + } + function bytes_equal(s1, s2) { + var len1 = s1.length; + var len2 = s2.length; + if (len1 === len2) { + var _off = 0; + while (true) { + var off = _off; + if (off === len1) { + return true; + } + var a = s1[off]; + var b = s2[off]; + if (a !== b) { + return false; + } + _off = off + 1 | 0; + continue; + } + ; + } else { + return false; + } + } + function bytes_greaterthan(s1, s2) { + return bytes_compare(s1, s2) > 0; + } + function bytes_greaterequal(s1, s2) { + return bytes_compare(s1, s2) >= 0; + } + function bytes_lessthan(s1, s2) { + return bytes_compare(s1, s2) < 0; + } + function bytes_lessequal(s1, s2) { + return bytes_compare(s1, s2) <= 0; + } + exports.create = create; + exports.get = get; + exports.set = set; + exports.bytes_compare = bytes_compare; + exports.bytes_greaterthan = bytes_greaterthan; + exports.bytes_greaterequal = bytes_greaterequal; + exports.bytes_lessthan = bytes_lessthan; + exports.bytes_lessequal = bytes_lessequal; + exports.bytes_equal = bytes_equal; + }); + + // node_modules/rescript/lib/js/caml_exceptions.js + var require_caml_exceptions = __commonJS((exports) => { + "use strict"; + var id = { + contents: 0 + }; + function create(str) { + id.contents = id.contents + 1 | 0; + return str + ("/" + id.contents); + } + function is_extension(e) { + if (e == null) { + return false; + } else { + return typeof e.RE_EXN_ID === "string"; + } + } + function exn_slot_name(x) { + return x.RE_EXN_ID; + } + exports.id = id; + exports.create = create; + exports.is_extension = is_extension; + exports.exn_slot_name = exn_slot_name; + }); + + // node_modules/rescript/lib/js/caml_js_exceptions.js + var require_caml_js_exceptions = __commonJS((exports) => { + "use strict"; + var Caml_option = require_caml_option(); + var Caml_exceptions = require_caml_exceptions(); + var $$Error = "JsError"; + function internalToOCamlException(e) { + if (Caml_exceptions.is_extension(e)) { + return e; + } else { + return { + RE_EXN_ID: "JsError", + _1: e + }; + } + } + function as_js_exn(exn) { + if (exn.RE_EXN_ID === $$Error) { + return Caml_option.some(exn._1); + } + } + exports.$$Error = $$Error; + exports.internalToOCamlException = internalToOCamlException; + exports.as_js_exn = as_js_exn; + }); + + // node_modules/rescript/lib/js/bytes.js + var require_bytes = __commonJS((exports) => { + "use strict"; + var Caml = require_caml(); + var Char = require_char(); + var Curry = require_curry(); + var Caml_bytes = require_caml_bytes(); + var Caml_js_exceptions = require_caml_js_exceptions(); + function unsafe_fill(s, i, l, c) { + if (l <= 0) { + return; + } + for (var k = i, k_finish = l + i | 0; k < k_finish; ++k) { + s[k] = c; + } + } + function unsafe_blit(s1, i1, s2, i2, len) { + if (len <= 0) { + return; + } + if (s1 === s2) { + if (i1 < i2) { + var range_a = (s1.length - i2 | 0) - 1 | 0; + var range_b = len - 1 | 0; + var range = range_a > range_b ? range_b : range_a; + for (var j = range; j >= 0; --j) { + s1[i2 + j | 0] = s1[i1 + j | 0]; + } + return; + } + if (i1 <= i2) { + return; + } + var range_a$1 = (s1.length - i1 | 0) - 1 | 0; + var range_b$1 = len - 1 | 0; + var range$1 = range_a$1 > range_b$1 ? range_b$1 : range_a$1; + for (var k = 0; k <= range$1; ++k) { + s1[i2 + k | 0] = s1[i1 + k | 0]; + } + return; + } + var off1 = s1.length - i1 | 0; + if (len <= off1) { + for (var i = 0; i < len; ++i) { + s2[i2 + i | 0] = s1[i1 + i | 0]; + } + return; + } + for (var i$1 = 0; i$1 < off1; ++i$1) { + s2[i2 + i$1 | 0] = s1[i1 + i$1 | 0]; + } + for (var i$2 = off1; i$2 < len; ++i$2) { + s2[i2 + i$2 | 0] = 0; + } + } + function make(n, c) { + var s = Caml_bytes.create(n); + unsafe_fill(s, 0, n, c); + return s; + } + function init(n, f) { + var s = Caml_bytes.create(n); + for (var i = 0; i < n; ++i) { + s[i] = Curry._1(f, i); + } + return s; + } + var empty = []; + function copy(s) { + var len = s.length; + var r = Caml_bytes.create(len); + unsafe_blit(s, 0, r, 0, len); + return r; + } + function to_string(a) { + var i = 0; + var len = a.length; + var s = ""; + var s_len = len; + if (i === 0 && len <= 4096 && len === a.length) { + return String.fromCharCode.apply(null, a); + } + var offset = 0; + while (s_len > 0) { + var next = s_len < 1024 ? s_len : 1024; + var tmp_bytes = new Array(next); + for (var k = 0; k < next; ++k) { + tmp_bytes[k] = a[k + offset | 0]; + } + s = s + String.fromCharCode.apply(null, tmp_bytes); + s_len = s_len - next | 0; + offset = offset + next | 0; + } + ; + return s; + } + function of_string(s) { + var len = s.length; + var res = new Array(len); + for (var i = 0; i < len; ++i) { + res[i] = s.codePointAt(i); + } + return res; + } + function sub(s, ofs, len) { + if (ofs < 0 || len < 0 || ofs > (s.length - len | 0)) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.sub / Bytes.sub", + Error: new Error() + }; + } + var r = Caml_bytes.create(len); + unsafe_blit(s, ofs, r, 0, len); + return r; + } + function sub_string(b, ofs, len) { + return to_string(sub(b, ofs, len)); + } + function $plus$plus(a, b) { + var c = a + b | 0; + var match = a < 0; + var match$1 = b < 0; + var match$2 = c < 0; + if (match) { + if (!match$1) { + return c; + } + if (match$2) { + return c; + } + throw { + RE_EXN_ID: "Invalid_argument", + _1: "Bytes.extend", + Error: new Error() + }; + } + if (match$1) { + return c; + } + if (match$2) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "Bytes.extend", + Error: new Error() + }; + } + return c; + } + function extend(s, left, right) { + var len = $plus$plus($plus$plus(s.length, left), right); + var r = Caml_bytes.create(len); + var match = left < 0 ? [ + -left | 0, + 0 + ] : [ + 0, + left + ]; + var dstoff = match[1]; + var srcoff = match[0]; + var cpylen = Caml.int_min(s.length - srcoff | 0, len - dstoff | 0); + if (cpylen > 0) { + unsafe_blit(s, srcoff, r, dstoff, cpylen); + } + return r; + } + function fill(s, ofs, len, c) { + if (ofs < 0 || len < 0 || ofs > (s.length - len | 0)) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.fill / Bytes.fill", + Error: new Error() + }; + } + unsafe_fill(s, ofs, len, c); + } + function blit(s1, ofs1, s2, ofs2, len) { + if (len < 0 || ofs1 < 0 || ofs1 > (s1.length - len | 0) || ofs2 < 0 || ofs2 > (s2.length - len | 0)) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "Bytes.blit", + Error: new Error() + }; + } + unsafe_blit(s1, ofs1, s2, ofs2, len); + } + function blit_string(s1, ofs1, s2, ofs2, len) { + if (len < 0 || ofs1 < 0 || ofs1 > (s1.length - len | 0) || ofs2 < 0 || ofs2 > (s2.length - len | 0)) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.blit / Bytes.blit_string", + Error: new Error() + }; + } + if (len <= 0) { + return; + } + var off1 = s1.length - ofs1 | 0; + if (len <= off1) { + for (var i = 0; i < len; ++i) { + s2[ofs2 + i | 0] = s1.codePointAt(ofs1 + i | 0); + } + return; + } + for (var i$1 = 0; i$1 < off1; ++i$1) { + s2[ofs2 + i$1 | 0] = s1.codePointAt(ofs1 + i$1 | 0); + } + for (var i$2 = off1; i$2 < len; ++i$2) { + s2[ofs2 + i$2 | 0] = 0; + } + } + function iter(f, a) { + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + Curry._1(f, a[i]); + } + } + function iteri(f, a) { + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + Curry._2(f, i, a[i]); + } + } + function ensure_ge(x, y) { + if (x >= y) { + return x; + } + throw { + RE_EXN_ID: "Invalid_argument", + _1: "Bytes.concat", + Error: new Error() + }; + } + function sum_lengths(_acc, seplen, _param) { + while (true) { + var param = _param; + var acc = _acc; + if (!param) { + return acc; + } + var tl = param.tl; + var hd = param.hd; + if (!tl) { + return hd.length + acc | 0; + } + _param = tl; + _acc = ensure_ge((hd.length + seplen | 0) + acc | 0, acc); + continue; + } + ; + } + function concat(sep, l) { + if (!l) { + return empty; + } + var seplen = sep.length; + var dst = Caml_bytes.create(sum_lengths(0, seplen, l)); + var _pos = 0; + var _param = l; + while (true) { + var param = _param; + var pos = _pos; + if (!param) { + return dst; + } + var tl = param.tl; + var hd = param.hd; + if (tl) { + unsafe_blit(hd, 0, dst, pos, hd.length); + unsafe_blit(sep, 0, dst, pos + hd.length | 0, seplen); + _param = tl; + _pos = (pos + hd.length | 0) + seplen | 0; + continue; + } + unsafe_blit(hd, 0, dst, pos, hd.length); + return dst; + } + ; + } + function cat(s1, s2) { + var l1 = s1.length; + var l2 = s2.length; + var r = Caml_bytes.create(l1 + l2 | 0); + unsafe_blit(s1, 0, r, 0, l1); + unsafe_blit(s2, 0, r, l1, l2); + return r; + } + function is_space(param) { + if (param > 13 || param < 9) { + return param === 32; + } else { + return param !== 11; + } + } + function trim(s) { + var len = s.length; + var i = 0; + while (i < len && is_space(s[i])) { + i = i + 1 | 0; + } + ; + var j = len - 1 | 0; + while (j >= i && is_space(s[j])) { + j = j - 1 | 0; + } + ; + if (j >= i) { + return sub(s, i, (j - i | 0) + 1 | 0); + } else { + return empty; + } + } + function escaped(s) { + var n = 0; + for (var i = 0, i_finish = s.length; i < i_finish; ++i) { + var match = s[i]; + n = n + (match >= 32 ? match > 92 || match < 34 ? match >= 127 ? 4 : 1 : match > 91 || match < 35 ? 2 : 1 : match >= 11 ? match !== 13 ? 4 : 2 : match >= 8 ? 2 : 4) | 0; + } + if (n === s.length) { + return copy(s); + } + var s$p = Caml_bytes.create(n); + n = 0; + for (var i$1 = 0, i_finish$1 = s.length; i$1 < i_finish$1; ++i$1) { + var c = s[i$1]; + var exit = 0; + if (c >= 35) { + if (c !== 92) { + if (c >= 127) { + exit = 1; + } else { + s$p[n] = c; + } + } else { + exit = 2; + } + } else if (c >= 32) { + if (c >= 34) { + exit = 2; + } else { + s$p[n] = c; + } + } else if (c >= 14) { + exit = 1; + } else { + switch (c) { + case 8: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = 98; + break; + case 9: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = 116; + break; + case 10: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = 110; + break; + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 11: + case 12: + exit = 1; + break; + case 13: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = 114; + break; + } + } + switch (exit) { + case 1: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = 48 + (c / 100 | 0) | 0; + n = n + 1 | 0; + s$p[n] = 48 + (c / 10 | 0) % 10 | 0; + n = n + 1 | 0; + s$p[n] = 48 + c % 10 | 0; + break; + case 2: + s$p[n] = 92; + n = n + 1 | 0; + s$p[n] = c; + break; + } + n = n + 1 | 0; + } + return s$p; + } + function map(f, s) { + var l = s.length; + if (l === 0) { + return s; + } + var r = Caml_bytes.create(l); + for (var i = 0; i < l; ++i) { + r[i] = Curry._1(f, s[i]); + } + return r; + } + function mapi(f, s) { + var l = s.length; + if (l === 0) { + return s; + } + var r = Caml_bytes.create(l); + for (var i = 0; i < l; ++i) { + r[i] = Curry._2(f, i, s[i]); + } + return r; + } + function uppercase_ascii(s) { + return map(Char.uppercase_ascii, s); + } + function lowercase_ascii(s) { + return map(Char.lowercase_ascii, s); + } + function apply1(f, s) { + if (s.length === 0) { + return s; + } + var r = copy(s); + r[0] = Curry._1(f, s[0]); + return r; + } + function capitalize_ascii(s) { + return apply1(Char.uppercase_ascii, s); + } + function uncapitalize_ascii(s) { + return apply1(Char.lowercase_ascii, s); + } + function index_rec(s, lim, _i, c) { + while (true) { + var i = _i; + if (i >= lim) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + if (s[i] === c) { + return i; + } + _i = i + 1 | 0; + continue; + } + ; + } + function index(s, c) { + return index_rec(s, s.length, 0, c); + } + function index_rec_opt(s, lim, _i, c) { + while (true) { + var i = _i; + if (i >= lim) { + return; + } + if (s[i] === c) { + return i; + } + _i = i + 1 | 0; + continue; + } + ; + } + function index_opt(s, c) { + return index_rec_opt(s, s.length, 0, c); + } + function index_from(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.index_from / Bytes.index_from", + Error: new Error() + }; + } + return index_rec(s, l, i, c); + } + function index_from_opt(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.index_from_opt / Bytes.index_from_opt", + Error: new Error() + }; + } + return index_rec_opt(s, l, i, c); + } + function rindex_rec(s, _i, c) { + while (true) { + var i = _i; + if (i < 0) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + if (s[i] === c) { + return i; + } + _i = i - 1 | 0; + continue; + } + ; + } + function rindex(s, c) { + return rindex_rec(s, s.length - 1 | 0, c); + } + function rindex_from(s, i, c) { + if (i < -1 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rindex_from / Bytes.rindex_from", + Error: new Error() + }; + } + return rindex_rec(s, i, c); + } + function rindex_rec_opt(s, _i, c) { + while (true) { + var i = _i; + if (i < 0) { + return; + } + if (s[i] === c) { + return i; + } + _i = i - 1 | 0; + continue; + } + ; + } + function rindex_opt(s, c) { + return rindex_rec_opt(s, s.length - 1 | 0, c); + } + function rindex_from_opt(s, i, c) { + if (i < -1 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rindex_from_opt / Bytes.rindex_from_opt", + Error: new Error() + }; + } + return rindex_rec_opt(s, i, c); + } + function contains_from(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.contains_from / Bytes.contains_from", + Error: new Error() + }; + } + try { + index_rec(s, l, i, c); + return true; + } catch (raw_exn) { + var exn = Caml_js_exceptions.internalToOCamlException(raw_exn); + if (exn.RE_EXN_ID === "Not_found") { + return false; + } + throw exn; + } + } + function contains(s, c) { + return contains_from(s, 0, c); + } + function rcontains_from(s, i, c) { + if (i < 0 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rcontains_from / Bytes.rcontains_from", + Error: new Error() + }; + } + try { + rindex_rec(s, i, c); + return true; + } catch (raw_exn) { + var exn = Caml_js_exceptions.internalToOCamlException(raw_exn); + if (exn.RE_EXN_ID === "Not_found") { + return false; + } + throw exn; + } + } + var compare = Caml_bytes.bytes_compare; + var equal = Caml_bytes.bytes_equal; + var unsafe_to_string = to_string; + var unsafe_of_string = of_string; + exports.make = make; + exports.init = init; + exports.empty = empty; + exports.copy = copy; + exports.of_string = of_string; + exports.to_string = to_string; + exports.sub = sub; + exports.sub_string = sub_string; + exports.extend = extend; + exports.fill = fill; + exports.blit = blit; + exports.blit_string = blit_string; + exports.concat = concat; + exports.cat = cat; + exports.iter = iter; + exports.iteri = iteri; + exports.map = map; + exports.mapi = mapi; + exports.trim = trim; + exports.escaped = escaped; + exports.index = index; + exports.index_opt = index_opt; + exports.rindex = rindex; + exports.rindex_opt = rindex_opt; + exports.index_from = index_from; + exports.index_from_opt = index_from_opt; + exports.rindex_from = rindex_from; + exports.rindex_from_opt = rindex_from_opt; + exports.contains = contains; + exports.contains_from = contains_from; + exports.rcontains_from = rcontains_from; + exports.uppercase_ascii = uppercase_ascii; + exports.lowercase_ascii = lowercase_ascii; + exports.capitalize_ascii = capitalize_ascii; + exports.uncapitalize_ascii = uncapitalize_ascii; + exports.compare = compare; + exports.equal = equal; + exports.unsafe_to_string = unsafe_to_string; + exports.unsafe_of_string = unsafe_of_string; + }); + + // node_modules/rescript/lib/js/js_int.js + var require_js_int = __commonJS((exports) => { + "use strict"; + function equal(x, y) { + return x === y; + } + var max = 2147483647; + var min = -2147483648; + exports.equal = equal; + exports.max = max; + exports.min = min; + }); + + // node_modules/rescript/lib/js/js_math.js + var require_js_math = __commonJS((exports) => { + "use strict"; + var Js_int = require_js_int(); + function unsafe_ceil(prim) { + return Math.ceil(prim); + } + function ceil_int(f) { + if (f > Js_int.max) { + return Js_int.max; + } else if (f < Js_int.min) { + return Js_int.min; + } else { + return Math.ceil(f); + } + } + function unsafe_floor(prim) { + return Math.floor(prim); + } + function floor_int(f) { + if (f > Js_int.max) { + return Js_int.max; + } else if (f < Js_int.min) { + return Js_int.min; + } else { + return Math.floor(f); + } + } + function random_int(min, max) { + return floor_int(Math.random() * (max - min | 0)) + min | 0; + } + var ceil = ceil_int; + var floor = floor_int; + exports.unsafe_ceil = unsafe_ceil; + exports.ceil_int = ceil_int; + exports.ceil = ceil; + exports.unsafe_floor = unsafe_floor; + exports.floor_int = floor_int; + exports.floor = floor; + exports.random_int = random_int; + }); + + // node_modules/rescript/lib/js/belt_Array.js + var require_belt_Array = __commonJS((exports) => { + "use strict"; + var Caml = require_caml(); + var Curry = require_curry(); + var Js_math = require_js_math(); + var Caml_option = require_caml_option(); + function get(arr, i) { + if (i >= 0 && i < arr.length) { + return Caml_option.some(arr[i]); + } + } + function getExn(arr, i) { + if (!(i >= 0 && i < arr.length)) { + throw { + RE_EXN_ID: "Assert_failure", + _1: [ + "belt_Array.ml", + 35, + 2 + ], + Error: new Error() + }; + } + return arr[i]; + } + function set(arr, i, v) { + if (i >= 0 && i < arr.length) { + arr[i] = v; + return true; + } else { + return false; + } + } + function setExn(arr, i, v) { + if (!(i >= 0 && i < arr.length)) { + throw { + RE_EXN_ID: "Assert_failure", + _1: [ + "belt_Array.ml", + 45, + 2 + ], + Error: new Error() + }; + } + arr[i] = v; + } + function swapUnsafe(xs, i, j) { + var tmp = xs[i]; + xs[i] = xs[j]; + xs[j] = tmp; + } + function shuffleInPlace(xs) { + var len = xs.length; + for (var i = 0; i < len; ++i) { + swapUnsafe(xs, i, Js_math.random_int(i, len)); + } + } + function shuffle(xs) { + var result = xs.slice(0); + shuffleInPlace(result); + return result; + } + function reverseInPlace(xs) { + var len = xs.length; + var ofs = 0; + for (var i = 0, i_finish = len / 2 | 0; i < i_finish; ++i) { + swapUnsafe(xs, ofs + i | 0, ((ofs + len | 0) - i | 0) - 1 | 0); + } + } + function reverse(xs) { + var len = xs.length; + var result = new Array(len); + for (var i = 0; i < len; ++i) { + result[i] = xs[(len - 1 | 0) - i | 0]; + } + return result; + } + function make(l, f) { + if (l <= 0) { + return []; + } + var res = new Array(l); + for (var i = 0; i < l; ++i) { + res[i] = f; + } + return res; + } + function makeByU(l, f) { + if (l <= 0) { + return []; + } + var res = new Array(l); + for (var i = 0; i < l; ++i) { + res[i] = f(i); + } + return res; + } + function makeBy(l, f) { + return makeByU(l, Curry.__1(f)); + } + function makeByAndShuffleU(l, f) { + var u = makeByU(l, f); + shuffleInPlace(u); + return u; + } + function makeByAndShuffle(l, f) { + return makeByAndShuffleU(l, Curry.__1(f)); + } + function range(start, finish) { + var cut = finish - start | 0; + if (cut < 0) { + return []; + } + var arr = new Array(cut + 1 | 0); + for (var i = 0; i <= cut; ++i) { + arr[i] = start + i | 0; + } + return arr; + } + function rangeBy(start, finish, step) { + var cut = finish - start | 0; + if (cut < 0 || step <= 0) { + return []; + } + var nb = (cut / step | 0) + 1 | 0; + var arr = new Array(nb); + var cur = start; + for (var i = 0; i < nb; ++i) { + arr[i] = cur; + cur = cur + step | 0; + } + return arr; + } + function zip(xs, ys) { + var lenx = xs.length; + var leny = ys.length; + var len = lenx < leny ? lenx : leny; + var s = new Array(len); + for (var i = 0; i < len; ++i) { + s[i] = [ + xs[i], + ys[i] + ]; + } + return s; + } + function zipByU(xs, ys, f) { + var lenx = xs.length; + var leny = ys.length; + var len = lenx < leny ? lenx : leny; + var s = new Array(len); + for (var i = 0; i < len; ++i) { + s[i] = f(xs[i], ys[i]); + } + return s; + } + function zipBy(xs, ys, f) { + return zipByU(xs, ys, Curry.__2(f)); + } + function concat(a1, a2) { + var l1 = a1.length; + var l2 = a2.length; + var a1a2 = new Array(l1 + l2 | 0); + for (var i = 0; i < l1; ++i) { + a1a2[i] = a1[i]; + } + for (var i$1 = 0; i$1 < l2; ++i$1) { + a1a2[l1 + i$1 | 0] = a2[i$1]; + } + return a1a2; + } + function concatMany(arrs) { + var lenArrs = arrs.length; + var totalLen = 0; + for (var i = 0; i < lenArrs; ++i) { + totalLen = totalLen + arrs[i].length | 0; + } + var result = new Array(totalLen); + totalLen = 0; + for (var j = 0; j < lenArrs; ++j) { + var cur = arrs[j]; + for (var k = 0, k_finish = cur.length; k < k_finish; ++k) { + result[totalLen] = cur[k]; + totalLen = totalLen + 1 | 0; + } + } + return result; + } + function slice(a, offset, len) { + if (len <= 0) { + return []; + } + var lena = a.length; + var ofs = offset < 0 ? Caml.int_max(lena + offset | 0, 0) : offset; + var hasLen = lena - ofs | 0; + var copyLength = hasLen < len ? hasLen : len; + if (copyLength <= 0) { + return []; + } + var result = new Array(copyLength); + for (var i = 0; i < copyLength; ++i) { + result[i] = a[ofs + i | 0]; + } + return result; + } + function sliceToEnd(a, offset) { + var lena = a.length; + var ofs = offset < 0 ? Caml.int_max(lena + offset | 0, 0) : offset; + var len = lena > ofs ? lena - ofs | 0 : 0; + var result = new Array(len); + for (var i = 0; i < len; ++i) { + result[i] = a[ofs + i | 0]; + } + return result; + } + function fill(a, offset, len, v) { + if (len <= 0) { + return; + } + var lena = a.length; + var ofs = offset < 0 ? Caml.int_max(lena + offset | 0, 0) : offset; + var hasLen = lena - ofs | 0; + var fillLength = hasLen < len ? hasLen : len; + if (fillLength <= 0) { + return; + } + for (var i = ofs, i_finish = ofs + fillLength | 0; i < i_finish; ++i) { + a[i] = v; + } + } + function blitUnsafe(a1, srcofs1, a2, srcofs2, blitLength) { + if (srcofs2 <= srcofs1) { + for (var j = 0; j < blitLength; ++j) { + a2[j + srcofs2 | 0] = a1[j + srcofs1 | 0]; + } + return; + } + for (var j$1 = blitLength - 1 | 0; j$1 >= 0; --j$1) { + a2[j$1 + srcofs2 | 0] = a1[j$1 + srcofs1 | 0]; + } + } + function blit(a1, ofs1, a2, ofs2, len) { + var lena1 = a1.length; + var lena2 = a2.length; + var srcofs1 = ofs1 < 0 ? Caml.int_max(lena1 + ofs1 | 0, 0) : ofs1; + var srcofs2 = ofs2 < 0 ? Caml.int_max(lena2 + ofs2 | 0, 0) : ofs2; + var blitLength = Caml.int_min(len, Caml.int_min(lena1 - srcofs1 | 0, lena2 - srcofs2 | 0)); + if (srcofs2 <= srcofs1) { + for (var j = 0; j < blitLength; ++j) { + a2[j + srcofs2 | 0] = a1[j + srcofs1 | 0]; + } + return; + } + for (var j$1 = blitLength - 1 | 0; j$1 >= 0; --j$1) { + a2[j$1 + srcofs2 | 0] = a1[j$1 + srcofs1 | 0]; + } + } + function forEachU(a, f) { + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + f(a[i]); + } + } + function forEach(a, f) { + forEachU(a, Curry.__1(f)); + } + function mapU(a, f) { + var l = a.length; + var r = new Array(l); + for (var i = 0; i < l; ++i) { + r[i] = f(a[i]); + } + return r; + } + function map(a, f) { + return mapU(a, Curry.__1(f)); + } + function flatMapU(a, f) { + return concatMany(mapU(a, f)); + } + function flatMap(a, f) { + return concatMany(mapU(a, Curry.__1(f))); + } + function getByU(a, p) { + var l = a.length; + var i = 0; + var r; + while (r === void 0 && i < l) { + var v = a[i]; + if (p(v)) { + r = Caml_option.some(v); + } + i = i + 1 | 0; + } + ; + return r; + } + function getBy(a, p) { + return getByU(a, Curry.__1(p)); + } + function getIndexByU(a, p) { + var l = a.length; + var i = 0; + var r; + while (r === void 0 && i < l) { + var v = a[i]; + if (p(v)) { + r = i; + } + i = i + 1 | 0; + } + ; + return r; + } + function getIndexBy(a, p) { + return getIndexByU(a, Curry.__1(p)); + } + function keepU(a, f) { + var l = a.length; + var r = new Array(l); + var j = 0; + for (var i = 0; i < l; ++i) { + var v = a[i]; + if (f(v)) { + r[j] = v; + j = j + 1 | 0; + } + } + r.length = j; + return r; + } + function keep(a, f) { + return keepU(a, Curry.__1(f)); + } + function keepWithIndexU(a, f) { + var l = a.length; + var r = new Array(l); + var j = 0; + for (var i = 0; i < l; ++i) { + var v = a[i]; + if (f(v, i)) { + r[j] = v; + j = j + 1 | 0; + } + } + r.length = j; + return r; + } + function keepWithIndex(a, f) { + return keepWithIndexU(a, Curry.__2(f)); + } + function keepMapU(a, f) { + var l = a.length; + var r = new Array(l); + var j = 0; + for (var i = 0; i < l; ++i) { + var v = a[i]; + var v$1 = f(v); + if (v$1 !== void 0) { + r[j] = Caml_option.valFromOption(v$1); + j = j + 1 | 0; + } + } + r.length = j; + return r; + } + function keepMap(a, f) { + return keepMapU(a, Curry.__1(f)); + } + function forEachWithIndexU(a, f) { + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + f(i, a[i]); + } + } + function forEachWithIndex(a, f) { + forEachWithIndexU(a, Curry.__2(f)); + } + function mapWithIndexU(a, f) { + var l = a.length; + var r = new Array(l); + for (var i = 0; i < l; ++i) { + r[i] = f(i, a[i]); + } + return r; + } + function mapWithIndex(a, f) { + return mapWithIndexU(a, Curry.__2(f)); + } + function reduceU(a, x, f) { + var r = x; + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + r = f(r, a[i]); + } + return r; + } + function reduce(a, x, f) { + return reduceU(a, x, Curry.__2(f)); + } + function reduceReverseU(a, x, f) { + var r = x; + for (var i = a.length - 1 | 0; i >= 0; --i) { + r = f(r, a[i]); + } + return r; + } + function reduceReverse(a, x, f) { + return reduceReverseU(a, x, Curry.__2(f)); + } + function reduceReverse2U(a, b, x, f) { + var r = x; + var len = Caml.int_min(a.length, b.length); + for (var i = len - 1 | 0; i >= 0; --i) { + r = f(r, a[i], b[i]); + } + return r; + } + function reduceReverse2(a, b, x, f) { + return reduceReverse2U(a, b, x, Curry.__3(f)); + } + function reduceWithIndexU(a, x, f) { + var r = x; + for (var i = 0, i_finish = a.length; i < i_finish; ++i) { + r = f(r, a[i], i); + } + return r; + } + function reduceWithIndex(a, x, f) { + return reduceWithIndexU(a, x, Curry.__3(f)); + } + function everyU(arr, b) { + var len = arr.length; + var _i = 0; + while (true) { + var i = _i; + if (i === len) { + return true; + } + if (!b(arr[i])) { + return false; + } + _i = i + 1 | 0; + continue; + } + ; + } + function every(arr, f) { + return everyU(arr, Curry.__1(f)); + } + function someU(arr, b) { + var len = arr.length; + var _i = 0; + while (true) { + var i = _i; + if (i === len) { + return false; + } + if (b(arr[i])) { + return true; + } + _i = i + 1 | 0; + continue; + } + ; + } + function some(arr, f) { + return someU(arr, Curry.__1(f)); + } + function everyAux2(arr1, arr2, _i, b, len) { + while (true) { + var i = _i; + if (i === len) { + return true; + } + if (!b(arr1[i], arr2[i])) { + return false; + } + _i = i + 1 | 0; + continue; + } + ; + } + function every2U(a, b, p) { + return everyAux2(a, b, 0, p, Caml.int_min(a.length, b.length)); + } + function every2(a, b, p) { + return every2U(a, b, Curry.__2(p)); + } + function some2U(a, b, p) { + var _i = 0; + var len = Caml.int_min(a.length, b.length); + while (true) { + var i = _i; + if (i === len) { + return false; + } + if (p(a[i], b[i])) { + return true; + } + _i = i + 1 | 0; + continue; + } + ; + } + function some2(a, b, p) { + return some2U(a, b, Curry.__2(p)); + } + function eqU(a, b, p) { + var lena = a.length; + var lenb = b.length; + if (lena === lenb) { + return everyAux2(a, b, 0, p, lena); + } else { + return false; + } + } + function eq(a, b, p) { + return eqU(a, b, Curry.__2(p)); + } + function cmpU(a, b, p) { + var lena = a.length; + var lenb = b.length; + if (lena > lenb) { + return 1; + } else if (lena < lenb) { + return -1; + } else { + var _i = 0; + while (true) { + var i = _i; + if (i === lena) { + return 0; + } + var c = p(a[i], b[i]); + if (c !== 0) { + return c; + } + _i = i + 1 | 0; + continue; + } + ; + } + } + function cmp(a, b, p) { + return cmpU(a, b, Curry.__2(p)); + } + function partitionU(a, f) { + var l = a.length; + var i = 0; + var j = 0; + var a1 = new Array(l); + var a2 = new Array(l); + for (var ii = 0; ii < l; ++ii) { + var v = a[ii]; + if (f(v)) { + a1[i] = v; + i = i + 1 | 0; + } else { + a2[j] = v; + j = j + 1 | 0; + } + } + a1.length = i; + a2.length = j; + return [ + a1, + a2 + ]; + } + function partition(a, f) { + return partitionU(a, Curry.__1(f)); + } + function unzip(a) { + var l = a.length; + var a1 = new Array(l); + var a2 = new Array(l); + for (var i = 0; i < l; ++i) { + var match = a[i]; + a1[i] = match[0]; + a2[i] = match[1]; + } + return [ + a1, + a2 + ]; + } + function joinWithU(a, sep, toString) { + var l = a.length; + if (l === 0) { + return ""; + } + var lastIndex = l - 1 | 0; + var _i = 0; + var _res = ""; + while (true) { + var res = _res; + var i = _i; + if (i === lastIndex) { + return res + toString(a[i]); + } + _res = res + (toString(a[i]) + sep); + _i = i + 1 | 0; + continue; + } + ; + } + function joinWith(a, sep, toString) { + return joinWithU(a, sep, Curry.__1(toString)); + } + function initU(n, f) { + var v = new Array(n); + for (var i = 0; i < n; ++i) { + v[i] = f(i); + } + return v; + } + function init(n, f) { + return initU(n, Curry.__1(f)); + } + exports.get = get; + exports.getExn = getExn; + exports.set = set; + exports.setExn = setExn; + exports.shuffleInPlace = shuffleInPlace; + exports.shuffle = shuffle; + exports.reverseInPlace = reverseInPlace; + exports.reverse = reverse; + exports.make = make; + exports.range = range; + exports.rangeBy = rangeBy; + exports.makeByU = makeByU; + exports.makeBy = makeBy; + exports.makeByAndShuffleU = makeByAndShuffleU; + exports.makeByAndShuffle = makeByAndShuffle; + exports.zip = zip; + exports.zipByU = zipByU; + exports.zipBy = zipBy; + exports.unzip = unzip; + exports.concat = concat; + exports.concatMany = concatMany; + exports.slice = slice; + exports.sliceToEnd = sliceToEnd; + exports.fill = fill; + exports.blit = blit; + exports.blitUnsafe = blitUnsafe; + exports.forEachU = forEachU; + exports.forEach = forEach; + exports.mapU = mapU; + exports.map = map; + exports.flatMapU = flatMapU; + exports.flatMap = flatMap; + exports.getByU = getByU; + exports.getBy = getBy; + exports.getIndexByU = getIndexByU; + exports.getIndexBy = getIndexBy; + exports.keepU = keepU; + exports.keep = keep; + exports.keepWithIndexU = keepWithIndexU; + exports.keepWithIndex = keepWithIndex; + exports.keepMapU = keepMapU; + exports.keepMap = keepMap; + exports.forEachWithIndexU = forEachWithIndexU; + exports.forEachWithIndex = forEachWithIndex; + exports.mapWithIndexU = mapWithIndexU; + exports.mapWithIndex = mapWithIndex; + exports.partitionU = partitionU; + exports.partition = partition; + exports.reduceU = reduceU; + exports.reduce = reduce; + exports.reduceReverseU = reduceReverseU; + exports.reduceReverse = reduceReverse; + exports.reduceReverse2U = reduceReverse2U; + exports.reduceReverse2 = reduceReverse2; + exports.reduceWithIndexU = reduceWithIndexU; + exports.reduceWithIndex = reduceWithIndex; + exports.joinWithU = joinWithU; + exports.joinWith = joinWith; + exports.someU = someU; + exports.some = some; + exports.everyU = everyU; + exports.every = every; + exports.every2U = every2U; + exports.every2 = every2; + exports.some2U = some2U; + exports.some2 = some2; + exports.cmpU = cmpU; + exports.cmp = cmp; + exports.eqU = eqU; + exports.eq = eq; + exports.initU = initU; + exports.init = init; + }); + + // node_modules/rescript/lib/js/belt_SortArray.js + var require_belt_SortArray = __commonJS((exports) => { + "use strict"; + var Curry = require_curry(); + var Belt_Array = require_belt_Array(); + function sortedLengthAuxMore(xs, _prec, _acc, len, lt) { + while (true) { + var acc = _acc; + var prec = _prec; + if (acc >= len) { + return acc; + } + var v = xs[acc]; + if (!lt(v, prec)) { + return acc; + } + _acc = acc + 1 | 0; + _prec = v; + continue; + } + ; + } + function strictlySortedLengthU(xs, lt) { + var len = xs.length; + if (len === 0 || len === 1) { + return len; + } + var x0 = xs[0]; + var x1 = xs[1]; + if (lt(x0, x1)) { + var _prec = x1; + var _acc = 2; + while (true) { + var acc = _acc; + var prec = _prec; + if (acc >= len) { + return acc; + } + var v = xs[acc]; + if (!lt(prec, v)) { + return acc; + } + _acc = acc + 1 | 0; + _prec = v; + continue; + } + ; + } else if (lt(x1, x0)) { + return -sortedLengthAuxMore(xs, x1, 2, len, lt) | 0; + } else { + return 1; + } + } + function strictlySortedLength(xs, lt) { + return strictlySortedLengthU(xs, Curry.__2(lt)); + } + function isSortedU(a, cmp) { + var len = a.length; + if (len === 0) { + return true; + } else { + var _i = 0; + var last_bound = len - 1 | 0; + while (true) { + var i = _i; + if (i === last_bound) { + return true; + } + if (cmp(a[i], a[i + 1 | 0]) > 0) { + return false; + } + _i = i + 1 | 0; + continue; + } + ; + } + } + function isSorted(a, cmp) { + return isSortedU(a, Curry.__2(cmp)); + } + function merge(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + var src1r = src1ofs + src1len | 0; + var src2r = src2ofs + src2len | 0; + var _i1 = src1ofs; + var _s1 = src[src1ofs]; + var _i2 = src2ofs; + var _s2 = src2[src2ofs]; + var _d = dstofs; + while (true) { + var d = _d; + var s2 = _s2; + var i2 = _i2; + var s1 = _s1; + var i1 = _i1; + if (cmp(s1, s2) <= 0) { + dst[d] = s1; + var i1$1 = i1 + 1 | 0; + if (i1$1 >= src1r) { + return Belt_Array.blitUnsafe(src2, i2, dst, d + 1 | 0, src2r - i2 | 0); + } + _d = d + 1 | 0; + _s1 = src[i1$1]; + _i1 = i1$1; + continue; + } + dst[d] = s2; + var i2$1 = i2 + 1 | 0; + if (i2$1 >= src2r) { + return Belt_Array.blitUnsafe(src, i1, dst, d + 1 | 0, src1r - i1 | 0); + } + _d = d + 1 | 0; + _s2 = src2[i2$1]; + _i2 = i2$1; + continue; + } + ; + } + function unionU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + var src1r = src1ofs + src1len | 0; + var src2r = src2ofs + src2len | 0; + var _i1 = src1ofs; + var _s1 = src[src1ofs]; + var _i2 = src2ofs; + var _s2 = src2[src2ofs]; + var _d = dstofs; + while (true) { + var d = _d; + var s2 = _s2; + var i2 = _i2; + var s1 = _s1; + var i1 = _i1; + var c = cmp(s1, s2); + if (c < 0) { + dst[d] = s1; + var i1$1 = i1 + 1 | 0; + var d$1 = d + 1 | 0; + if (i1$1 < src1r) { + _d = d$1; + _s1 = src[i1$1]; + _i1 = i1$1; + continue; + } + Belt_Array.blitUnsafe(src2, i2, dst, d$1, src2r - i2 | 0); + return (d$1 + src2r | 0) - i2 | 0; + } + if (c === 0) { + dst[d] = s1; + var i1$2 = i1 + 1 | 0; + var i2$1 = i2 + 1 | 0; + var d$2 = d + 1 | 0; + if (!(i1$2 < src1r && i2$1 < src2r)) { + if (i1$2 === src1r) { + Belt_Array.blitUnsafe(src2, i2$1, dst, d$2, src2r - i2$1 | 0); + return (d$2 + src2r | 0) - i2$1 | 0; + } else { + Belt_Array.blitUnsafe(src, i1$2, dst, d$2, src1r - i1$2 | 0); + return (d$2 + src1r | 0) - i1$2 | 0; + } + } + _d = d$2; + _s2 = src2[i2$1]; + _i2 = i2$1; + _s1 = src[i1$2]; + _i1 = i1$2; + continue; + } + dst[d] = s2; + var i2$2 = i2 + 1 | 0; + var d$3 = d + 1 | 0; + if (i2$2 < src2r) { + _d = d$3; + _s2 = src2[i2$2]; + _i2 = i2$2; + continue; + } + Belt_Array.blitUnsafe(src, i1, dst, d$3, src1r - i1 | 0); + return (d$3 + src1r | 0) - i1 | 0; + } + ; + } + function union(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + return unionU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, Curry.__2(cmp)); + } + function intersectU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + var src1r = src1ofs + src1len | 0; + var src2r = src2ofs + src2len | 0; + var _i1 = src1ofs; + var _s1 = src[src1ofs]; + var _i2 = src2ofs; + var _s2 = src2[src2ofs]; + var _d = dstofs; + while (true) { + var d = _d; + var s2 = _s2; + var i2 = _i2; + var s1 = _s1; + var i1 = _i1; + var c = cmp(s1, s2); + if (c < 0) { + var i1$1 = i1 + 1 | 0; + if (i1$1 >= src1r) { + return d; + } + _s1 = src[i1$1]; + _i1 = i1$1; + continue; + } + if (c === 0) { + dst[d] = s1; + var i1$2 = i1 + 1 | 0; + var i2$1 = i2 + 1 | 0; + var d$1 = d + 1 | 0; + if (!(i1$2 < src1r && i2$1 < src2r)) { + return d$1; + } + _d = d$1; + _s2 = src2[i2$1]; + _i2 = i2$1; + _s1 = src[i1$2]; + _i1 = i1$2; + continue; + } + var i2$2 = i2 + 1 | 0; + if (i2$2 >= src2r) { + return d; + } + _s2 = src2[i2$2]; + _i2 = i2$2; + continue; + } + ; + } + function intersect(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + return intersectU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, Curry.__2(cmp)); + } + function diffU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + var src1r = src1ofs + src1len | 0; + var src2r = src2ofs + src2len | 0; + var _i1 = src1ofs; + var _s1 = src[src1ofs]; + var _i2 = src2ofs; + var _s2 = src2[src2ofs]; + var _d = dstofs; + while (true) { + var d = _d; + var s2 = _s2; + var i2 = _i2; + var s1 = _s1; + var i1 = _i1; + var c = cmp(s1, s2); + if (c < 0) { + dst[d] = s1; + var d$1 = d + 1 | 0; + var i1$1 = i1 + 1 | 0; + if (i1$1 >= src1r) { + return d$1; + } + _d = d$1; + _s1 = src[i1$1]; + _i1 = i1$1; + continue; + } + if (c === 0) { + var i1$2 = i1 + 1 | 0; + var i2$1 = i2 + 1 | 0; + if (!(i1$2 < src1r && i2$1 < src2r)) { + if (i1$2 === src1r) { + return d; + } else { + Belt_Array.blitUnsafe(src, i1$2, dst, d, src1r - i1$2 | 0); + return (d + src1r | 0) - i1$2 | 0; + } + } + _s2 = src2[i2$1]; + _i2 = i2$1; + _s1 = src[i1$2]; + _i1 = i1$2; + continue; + } + var i2$2 = i2 + 1 | 0; + if (i2$2 < src2r) { + _s2 = src2[i2$2]; + _i2 = i2$2; + continue; + } + Belt_Array.blitUnsafe(src, i1, dst, d, src1r - i1 | 0); + return (d + src1r | 0) - i1 | 0; + } + ; + } + function diff(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) { + return diffU(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, Curry.__2(cmp)); + } + function insertionSort(src, srcofs, dst, dstofs, len, cmp) { + for (var i = 0; i < len; ++i) { + var e = src[srcofs + i | 0]; + var j = (dstofs + i | 0) - 1 | 0; + while (j >= dstofs && cmp(dst[j], e) > 0) { + dst[j + 1 | 0] = dst[j]; + j = j - 1 | 0; + } + ; + dst[j + 1 | 0] = e; + } + } + function sortTo(src, srcofs, dst, dstofs, len, cmp) { + if (len <= 5) { + return insertionSort(src, srcofs, dst, dstofs, len, cmp); + } + var l1 = len / 2 | 0; + var l2 = len - l1 | 0; + sortTo(src, srcofs + l1 | 0, dst, dstofs + l1 | 0, l2, cmp); + sortTo(src, srcofs, src, srcofs + l2 | 0, l1, cmp); + merge(src, srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs, cmp); + } + function stableSortInPlaceByU(a, cmp) { + var l = a.length; + if (l <= 5) { + return insertionSort(a, 0, a, 0, l, cmp); + } + var l1 = l / 2 | 0; + var l2 = l - l1 | 0; + var t = new Array(l2); + sortTo(a, l1, t, 0, l2, cmp); + sortTo(a, 0, a, l2, l1, cmp); + merge(a, l2, l1, t, 0, l2, a, 0, cmp); + } + function stableSortInPlaceBy(a, cmp) { + stableSortInPlaceByU(a, Curry.__2(cmp)); + } + function stableSortByU(a, cmp) { + var b = a.slice(0); + stableSortInPlaceByU(b, cmp); + return b; + } + function stableSortBy(a, cmp) { + return stableSortByU(a, Curry.__2(cmp)); + } + function binarySearchByU(sorted, key, cmp) { + var len = sorted.length; + if (len === 0) { + return -1; + } + var lo = sorted[0]; + var c = cmp(key, lo); + if (c < 0) { + return -1; + } + var hi = sorted[len - 1 | 0]; + var c2 = cmp(key, hi); + if (c2 > 0) { + return -(len + 1 | 0) | 0; + } else { + var _lo = 0; + var _hi = len - 1 | 0; + while (true) { + var hi$1 = _hi; + var lo$1 = _lo; + var mid = (lo$1 + hi$1 | 0) / 2 | 0; + var midVal = sorted[mid]; + var c$1 = cmp(key, midVal); + if (c$1 === 0) { + return mid; + } + if (c$1 < 0) { + if (hi$1 === mid) { + if (cmp(sorted[lo$1], key) === 0) { + return lo$1; + } else { + return -(hi$1 + 1 | 0) | 0; + } + } + _hi = mid; + continue; + } + if (lo$1 === mid) { + if (cmp(sorted[hi$1], key) === 0) { + return hi$1; + } else { + return -(hi$1 + 1 | 0) | 0; + } + } + _lo = mid; + continue; + } + ; + } + } + function binarySearchBy(sorted, key, cmp) { + return binarySearchByU(sorted, key, Curry.__2(cmp)); + } + var Int; + var $$String; + exports.Int = Int; + exports.$$String = $$String; + exports.strictlySortedLengthU = strictlySortedLengthU; + exports.strictlySortedLength = strictlySortedLength; + exports.isSortedU = isSortedU; + exports.isSorted = isSorted; + exports.stableSortInPlaceByU = stableSortInPlaceByU; + exports.stableSortInPlaceBy = stableSortInPlaceBy; + exports.stableSortByU = stableSortByU; + exports.stableSortBy = stableSortBy; + exports.binarySearchByU = binarySearchByU; + exports.binarySearchBy = binarySearchBy; + exports.unionU = unionU; + exports.union = union; + exports.intersectU = intersectU; + exports.intersect = intersect; + exports.diffU = diffU; + exports.diff = diff; + }); + + // node_modules/rescript/lib/js/belt_List.js + var require_belt_List = __commonJS((exports) => { + "use strict"; + var Curry = require_curry(); + var Belt_Array = require_belt_Array(); + var Caml_option = require_caml_option(); + var Belt_SortArray = require_belt_SortArray(); + function head(x) { + if (x) { + return Caml_option.some(x.hd); + } + } + function headExn(x) { + if (x) { + return x.hd; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + function tail(x) { + if (x) { + return x.tl; + } + } + function tailExn(x) { + if (x) { + return x.tl; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + function add(xs, x) { + return { + hd: x, + tl: xs + }; + } + function get(x, n) { + if (n < 0) { + return; + } else { + var _x = x; + var _n = n; + while (true) { + var n$1 = _n; + var x$1 = _x; + if (!x$1) { + return; + } + if (n$1 === 0) { + return Caml_option.some(x$1.hd); + } + _n = n$1 - 1 | 0; + _x = x$1.tl; + continue; + } + ; + } + } + function getExn(x, n) { + if (n < 0) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + var _x = x; + var _n = n; + while (true) { + var n$1 = _n; + var x$1 = _x; + if (x$1) { + if (n$1 === 0) { + return x$1.hd; + } + _n = n$1 - 1 | 0; + _x = x$1.tl; + continue; + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + ; + } + function partitionAux(p, _cell, _precX, _precY) { + while (true) { + var precY = _precY; + var precX = _precX; + var cell = _cell; + if (!cell) { + return; + } + var t = cell.tl; + var h = cell.hd; + var next = { + hd: h, + tl: 0 + }; + if (p(h)) { + precX.tl = next; + _precX = next; + _cell = t; + continue; + } + precY.tl = next; + _precY = next; + _cell = t; + continue; + } + ; + } + function splitAux(_cell, _precX, _precY) { + while (true) { + var precY = _precY; + var precX = _precX; + var cell = _cell; + if (!cell) { + return; + } + var match = cell.hd; + var nextA = { + hd: match[0], + tl: 0 + }; + var nextB = { + hd: match[1], + tl: 0 + }; + precX.tl = nextA; + precY.tl = nextB; + _precY = nextB; + _precX = nextA; + _cell = cell.tl; + continue; + } + ; + } + function copyAuxCont(_cellX, _prec) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return prec; + } + var next = { + hd: cellX.hd, + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + continue; + } + ; + } + function copyAuxWitFilter(f, _cellX, _prec) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h)) { + var next = { + hd: h, + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue; + } + _cellX = t; + continue; + } + ; + } + function copyAuxWithFilterIndex(f, _cellX, _prec, _i) { + while (true) { + var i = _i; + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h, i)) { + var next = { + hd: h, + tl: 0 + }; + prec.tl = next; + _i = i + 1 | 0; + _prec = next; + _cellX = t; + continue; + } + _i = i + 1 | 0; + _cellX = t; + continue; + } + ; + } + function copyAuxWitFilterMap(f, _cellX, _prec) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return; + } + var t = cellX.tl; + var h = f(cellX.hd); + if (h !== void 0) { + var next = { + hd: Caml_option.valFromOption(h), + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue; + } + _cellX = t; + continue; + } + ; + } + function removeAssocAuxWithMap(_cellX, x, _prec, f) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return false; + } + var t = cellX.tl; + var h = cellX.hd; + if (f(h[0], x)) { + prec.tl = t; + return true; + } + var next = { + hd: h, + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue; + } + ; + } + function setAssocAuxWithMap(_cellX, x, k, _prec, eq2) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return false; + } + var t = cellX.tl; + var h = cellX.hd; + if (eq2(h[0], x)) { + prec.tl = { + hd: [ + x, + k + ], + tl: t + }; + return true; + } + var next = { + hd: h, + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = t; + continue; + } + ; + } + function copyAuxWithMap(_cellX, _prec, f) { + while (true) { + var prec = _prec; + var cellX = _cellX; + if (!cellX) { + return; + } + var next = { + hd: f(cellX.hd), + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + continue; + } + ; + } + function zipAux(_cellX, _cellY, _prec) { + while (true) { + var prec = _prec; + var cellY = _cellY; + var cellX = _cellX; + if (!cellX) { + return; + } + if (!cellY) { + return; + } + var next = { + hd: [ + cellX.hd, + cellY.hd + ], + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellY = cellY.tl; + _cellX = cellX.tl; + continue; + } + ; + } + function copyAuxWithMap2(f, _cellX, _cellY, _prec) { + while (true) { + var prec = _prec; + var cellY = _cellY; + var cellX = _cellX; + if (!cellX) { + return; + } + if (!cellY) { + return; + } + var next = { + hd: f(cellX.hd, cellY.hd), + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellY = cellY.tl; + _cellX = cellX.tl; + continue; + } + ; + } + function copyAuxWithMapI(f, _i, _cellX, _prec) { + while (true) { + var prec = _prec; + var cellX = _cellX; + var i = _i; + if (!cellX) { + return; + } + var next = { + hd: f(i, cellX.hd), + tl: 0 + }; + prec.tl = next; + _prec = next; + _cellX = cellX.tl; + _i = i + 1 | 0; + continue; + } + ; + } + function takeAux(_n, _cell, _prec) { + while (true) { + var prec = _prec; + var cell = _cell; + var n = _n; + if (n === 0) { + return true; + } + if (!cell) { + return false; + } + var cell$1 = { + hd: cell.hd, + tl: 0 + }; + prec.tl = cell$1; + _prec = cell$1; + _cell = cell.tl; + _n = n - 1 | 0; + continue; + } + ; + } + function splitAtAux(_n, _cell, _prec) { + while (true) { + var prec = _prec; + var cell = _cell; + var n = _n; + if (n === 0) { + return cell; + } + if (!cell) { + return; + } + var cell$1 = { + hd: cell.hd, + tl: 0 + }; + prec.tl = cell$1; + _prec = cell$1; + _cell = cell.tl; + _n = n - 1 | 0; + continue; + } + ; + } + function take(lst, n) { + if (n < 0) { + return; + } + if (n === 0) { + return 0; + } + if (!lst) { + return; + } + var cell = { + hd: lst.hd, + tl: 0 + }; + var has2 = takeAux(n - 1 | 0, lst.tl, cell); + if (has2) { + return cell; + } + } + function drop(lst, n) { + if (n < 0) { + return; + } else { + var _l = lst; + var _n = n; + while (true) { + var n$1 = _n; + var l = _l; + if (n$1 === 0) { + return l; + } + if (!l) { + return; + } + _n = n$1 - 1 | 0; + _l = l.tl; + continue; + } + ; + } + } + function splitAt(lst, n) { + if (n < 0) { + return; + } + if (n === 0) { + return [ + 0, + lst + ]; + } + if (!lst) { + return; + } + var cell = { + hd: lst.hd, + tl: 0 + }; + var rest = splitAtAux(n - 1 | 0, lst.tl, cell); + if (rest !== void 0) { + return [ + cell, + rest + ]; + } + } + function concat(xs, ys) { + if (!xs) { + return ys; + } + var cell = { + hd: xs.hd, + tl: 0 + }; + copyAuxCont(xs.tl, cell).tl = ys; + return cell; + } + function mapU(xs, f) { + if (!xs) { + return 0; + } + var cell = { + hd: f(xs.hd), + tl: 0 + }; + copyAuxWithMap(xs.tl, cell, f); + return cell; + } + function map(xs, f) { + return mapU(xs, Curry.__1(f)); + } + function zipByU(l1, l2, f) { + if (!l1) { + return 0; + } + if (!l2) { + return 0; + } + var cell = { + hd: f(l1.hd, l2.hd), + tl: 0 + }; + copyAuxWithMap2(f, l1.tl, l2.tl, cell); + return cell; + } + function zipBy(l1, l2, f) { + return zipByU(l1, l2, Curry.__2(f)); + } + function mapWithIndexU(xs, f) { + if (!xs) { + return 0; + } + var cell = { + hd: f(0, xs.hd), + tl: 0 + }; + copyAuxWithMapI(f, 1, xs.tl, cell); + return cell; + } + function mapWithIndex(xs, f) { + return mapWithIndexU(xs, Curry.__2(f)); + } + function makeByU(n, f) { + if (n <= 0) { + return 0; + } + var headX = { + hd: f(0), + tl: 0 + }; + var cur = headX; + var i = 1; + while (i < n) { + var v = { + hd: f(i), + tl: 0 + }; + cur.tl = v; + cur = v; + i = i + 1 | 0; + } + ; + return headX; + } + function makeBy(n, f) { + return makeByU(n, Curry.__1(f)); + } + function make(n, v) { + if (n <= 0) { + return 0; + } + var headX = { + hd: v, + tl: 0 + }; + var cur = headX; + var i = 1; + while (i < n) { + var v$1 = { + hd: v, + tl: 0 + }; + cur.tl = v$1; + cur = v$1; + i = i + 1 | 0; + } + ; + return headX; + } + function length(xs) { + var _x = xs; + var _acc = 0; + while (true) { + var acc = _acc; + var x = _x; + if (!x) { + return acc; + } + _acc = acc + 1 | 0; + _x = x.tl; + continue; + } + ; + } + function fillAux(arr, _i, _x) { + while (true) { + var x = _x; + var i = _i; + if (!x) { + return; + } + arr[i] = x.hd; + _x = x.tl; + _i = i + 1 | 0; + continue; + } + ; + } + function fromArray(a) { + var _i = a.length - 1 | 0; + var _res = 0; + while (true) { + var res = _res; + var i = _i; + if (i < 0) { + return res; + } + _res = { + hd: a[i], + tl: res + }; + _i = i - 1 | 0; + continue; + } + ; + } + function toArray(x) { + var len = length(x); + var arr = new Array(len); + fillAux(arr, 0, x); + return arr; + } + function shuffle(xs) { + var v = toArray(xs); + Belt_Array.shuffleInPlace(v); + return fromArray(v); + } + function reverseConcat(_l1, _l2) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return l2; + } + _l2 = { + hd: l1.hd, + tl: l2 + }; + _l1 = l1.tl; + continue; + } + ; + } + function reverse(l) { + return reverseConcat(l, 0); + } + function flattenAux(_prec, _xs) { + while (true) { + var xs = _xs; + var prec = _prec; + if (xs) { + _xs = xs.tl; + _prec = copyAuxCont(xs.hd, prec); + continue; + } + prec.tl = 0; + return; + } + ; + } + function flatten(_xs) { + while (true) { + var xs = _xs; + if (!xs) { + return 0; + } + var match = xs.hd; + if (match) { + var cell = { + hd: match.hd, + tl: 0 + }; + flattenAux(copyAuxCont(match.tl, cell), xs.tl); + return cell; + } + _xs = xs.tl; + continue; + } + ; + } + function concatMany(xs) { + var len = xs.length; + if (len === 1) { + return xs[0]; + } + if (len === 0) { + return 0; + } + var len$1 = xs.length; + var v = xs[len$1 - 1 | 0]; + for (var i = len$1 - 2 | 0; i >= 0; --i) { + v = concat(xs[i], v); + } + return v; + } + function mapReverseU(l, f) { + var _accu = 0; + var _xs = l; + while (true) { + var xs = _xs; + var accu = _accu; + if (!xs) { + return accu; + } + _xs = xs.tl; + _accu = { + hd: f(xs.hd), + tl: accu + }; + continue; + } + ; + } + function mapReverse(l, f) { + return mapReverseU(l, Curry.__1(f)); + } + function forEachU(_xs, f) { + while (true) { + var xs = _xs; + if (!xs) { + return; + } + f(xs.hd); + _xs = xs.tl; + continue; + } + ; + } + function forEach(xs, f) { + forEachU(xs, Curry.__1(f)); + } + function forEachWithIndexU(l, f) { + var _xs = l; + var _i = 0; + while (true) { + var i = _i; + var xs = _xs; + if (!xs) { + return; + } + f(i, xs.hd); + _i = i + 1 | 0; + _xs = xs.tl; + continue; + } + ; + } + function forEachWithIndex(l, f) { + forEachWithIndexU(l, Curry.__2(f)); + } + function reduceU(_l, _accu, f) { + while (true) { + var accu = _accu; + var l = _l; + if (!l) { + return accu; + } + _accu = f(accu, l.hd); + _l = l.tl; + continue; + } + ; + } + function reduce(l, accu, f) { + return reduceU(l, accu, Curry.__2(f)); + } + function reduceReverseUnsafeU(l, accu, f) { + if (l) { + return f(reduceReverseUnsafeU(l.tl, accu, f), l.hd); + } else { + return accu; + } + } + function reduceReverseU(l, acc, f) { + var len = length(l); + if (len < 1e3) { + return reduceReverseUnsafeU(l, acc, f); + } else { + return Belt_Array.reduceReverseU(toArray(l), acc, f); + } + } + function reduceReverse(l, accu, f) { + return reduceReverseU(l, accu, Curry.__2(f)); + } + function reduceWithIndexU(l, acc, f) { + var _l = l; + var _acc = acc; + var _i = 0; + while (true) { + var i = _i; + var acc$1 = _acc; + var l$1 = _l; + if (!l$1) { + return acc$1; + } + _i = i + 1 | 0; + _acc = f(acc$1, l$1.hd, i); + _l = l$1.tl; + continue; + } + ; + } + function reduceWithIndex(l, acc, f) { + return reduceWithIndexU(l, acc, Curry.__3(f)); + } + function mapReverse2U(l1, l2, f) { + var _l1 = l1; + var _l2 = l2; + var _accu = 0; + while (true) { + var accu = _accu; + var l2$1 = _l2; + var l1$1 = _l1; + if (!l1$1) { + return accu; + } + if (!l2$1) { + return accu; + } + _accu = { + hd: f(l1$1.hd, l2$1.hd), + tl: accu + }; + _l2 = l2$1.tl; + _l1 = l1$1.tl; + continue; + } + ; + } + function mapReverse2(l1, l2, f) { + return mapReverse2U(l1, l2, Curry.__2(f)); + } + function forEach2U(_l1, _l2, f) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return; + } + if (!l2) { + return; + } + f(l1.hd, l2.hd); + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function forEach2(l1, l2, f) { + forEach2U(l1, l2, Curry.__2(f)); + } + function reduce2U(_l1, _l2, _accu, f) { + while (true) { + var accu = _accu; + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return accu; + } + if (!l2) { + return accu; + } + _accu = f(accu, l1.hd, l2.hd); + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function reduce2(l1, l2, acc, f) { + return reduce2U(l1, l2, acc, Curry.__3(f)); + } + function reduceReverse2UnsafeU(l1, l2, accu, f) { + if (l1 && l2) { + return f(reduceReverse2UnsafeU(l1.tl, l2.tl, accu, f), l1.hd, l2.hd); + } else { + return accu; + } + } + function reduceReverse2U(l1, l2, acc, f) { + var len = length(l1); + if (len < 1e3) { + return reduceReverse2UnsafeU(l1, l2, acc, f); + } else { + return Belt_Array.reduceReverse2U(toArray(l1), toArray(l2), acc, f); + } + } + function reduceReverse2(l1, l2, acc, f) { + return reduceReverse2U(l1, l2, acc, Curry.__3(f)); + } + function everyU(_xs, p) { + while (true) { + var xs = _xs; + if (!xs) { + return true; + } + if (!p(xs.hd)) { + return false; + } + _xs = xs.tl; + continue; + } + ; + } + function every(xs, p) { + return everyU(xs, Curry.__1(p)); + } + function someU(_xs, p) { + while (true) { + var xs = _xs; + if (!xs) { + return false; + } + if (p(xs.hd)) { + return true; + } + _xs = xs.tl; + continue; + } + ; + } + function some(xs, p) { + return someU(xs, Curry.__1(p)); + } + function every2U(_l1, _l2, p) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return true; + } + if (!l2) { + return true; + } + if (!p(l1.hd, l2.hd)) { + return false; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function every2(l1, l2, p) { + return every2U(l1, l2, Curry.__2(p)); + } + function cmpByLength(_l1, _l2) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + if (l2) { + return -1; + } else { + return 0; + } + } + if (!l2) { + return 1; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function cmpU(_l1, _l2, p) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + if (l2) { + return -1; + } else { + return 0; + } + } + if (!l2) { + return 1; + } + var c = p(l1.hd, l2.hd); + if (c !== 0) { + return c; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function cmp(l1, l2, f) { + return cmpU(l1, l2, Curry.__2(f)); + } + function eqU(_l1, _l2, p) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + if (l2) { + return false; + } else { + return true; + } + } + if (!l2) { + return false; + } + if (!p(l1.hd, l2.hd)) { + return false; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function eq(l1, l2, f) { + return eqU(l1, l2, Curry.__2(f)); + } + function some2U(_l1, _l2, p) { + while (true) { + var l2 = _l2; + var l1 = _l1; + if (!l1) { + return false; + } + if (!l2) { + return false; + } + if (p(l1.hd, l2.hd)) { + return true; + } + _l2 = l2.tl; + _l1 = l1.tl; + continue; + } + ; + } + function some2(l1, l2, p) { + return some2U(l1, l2, Curry.__2(p)); + } + function hasU(_xs, x, eq2) { + while (true) { + var xs = _xs; + if (!xs) { + return false; + } + if (eq2(xs.hd, x)) { + return true; + } + _xs = xs.tl; + continue; + } + ; + } + function has(xs, x, eq2) { + return hasU(xs, x, Curry.__2(eq2)); + } + function getAssocU(_xs, x, eq2) { + while (true) { + var xs = _xs; + if (!xs) { + return; + } + var match = xs.hd; + if (eq2(match[0], x)) { + return Caml_option.some(match[1]); + } + _xs = xs.tl; + continue; + } + ; + } + function getAssoc(xs, x, eq2) { + return getAssocU(xs, x, Curry.__2(eq2)); + } + function hasAssocU(_xs, x, eq2) { + while (true) { + var xs = _xs; + if (!xs) { + return false; + } + if (eq2(xs.hd[0], x)) { + return true; + } + _xs = xs.tl; + continue; + } + ; + } + function hasAssoc(xs, x, eq2) { + return hasAssocU(xs, x, Curry.__2(eq2)); + } + function removeAssocU(xs, x, eq2) { + if (!xs) { + return 0; + } + var l = xs.tl; + var pair = xs.hd; + if (eq2(pair[0], x)) { + return l; + } + var cell = { + hd: pair, + tl: 0 + }; + var removed = removeAssocAuxWithMap(l, x, cell, eq2); + if (removed) { + return cell; + } else { + return xs; + } + } + function removeAssoc(xs, x, eq2) { + return removeAssocU(xs, x, Curry.__2(eq2)); + } + function setAssocU(xs, x, k, eq2) { + if (!xs) { + return { + hd: [ + x, + k + ], + tl: 0 + }; + } + var l = xs.tl; + var pair = xs.hd; + if (eq2(pair[0], x)) { + return { + hd: [ + x, + k + ], + tl: l + }; + } + var cell = { + hd: pair, + tl: 0 + }; + var replaced = setAssocAuxWithMap(l, x, k, cell, eq2); + if (replaced) { + return cell; + } else { + return { + hd: [ + x, + k + ], + tl: xs + }; + } + } + function setAssoc(xs, x, k, eq2) { + return setAssocU(xs, x, k, Curry.__2(eq2)); + } + function sortU(xs, cmp2) { + var arr = toArray(xs); + Belt_SortArray.stableSortInPlaceByU(arr, cmp2); + return fromArray(arr); + } + function sort(xs, cmp2) { + return sortU(xs, Curry.__2(cmp2)); + } + function getByU(_xs, p) { + while (true) { + var xs = _xs; + if (!xs) { + return; + } + var x = xs.hd; + if (p(x)) { + return Caml_option.some(x); + } + _xs = xs.tl; + continue; + } + ; + } + function getBy(xs, p) { + return getByU(xs, Curry.__1(p)); + } + function keepU(_xs, p) { + while (true) { + var xs = _xs; + if (!xs) { + return 0; + } + var t = xs.tl; + var h = xs.hd; + if (p(h)) { + var cell = { + hd: h, + tl: 0 + }; + copyAuxWitFilter(p, t, cell); + return cell; + } + _xs = t; + continue; + } + ; + } + function keep(xs, p) { + return keepU(xs, Curry.__1(p)); + } + function keepWithIndexU(xs, p) { + var _xs = xs; + var _i = 0; + while (true) { + var i = _i; + var xs$1 = _xs; + if (!xs$1) { + return 0; + } + var t = xs$1.tl; + var h = xs$1.hd; + if (p(h, i)) { + var cell = { + hd: h, + tl: 0 + }; + copyAuxWithFilterIndex(p, t, cell, i + 1 | 0); + return cell; + } + _i = i + 1 | 0; + _xs = t; + continue; + } + ; + } + function keepWithIndex(xs, p) { + return keepWithIndexU(xs, Curry.__2(p)); + } + function keepMapU(_xs, p) { + while (true) { + var xs = _xs; + if (!xs) { + return 0; + } + var t = xs.tl; + var h = p(xs.hd); + if (h !== void 0) { + var cell = { + hd: Caml_option.valFromOption(h), + tl: 0 + }; + copyAuxWitFilterMap(p, t, cell); + return cell; + } + _xs = t; + continue; + } + ; + } + function keepMap(xs, p) { + return keepMapU(xs, Curry.__1(p)); + } + function partitionU(l, p) { + if (!l) { + return [ + 0, + 0 + ]; + } + var h = l.hd; + var nextX = { + hd: h, + tl: 0 + }; + var nextY = { + hd: h, + tl: 0 + }; + var b = p(h); + partitionAux(p, l.tl, nextX, nextY); + if (b) { + return [ + nextX, + nextY.tl + ]; + } else { + return [ + nextX.tl, + nextY + ]; + } + } + function partition(l, p) { + return partitionU(l, Curry.__1(p)); + } + function unzip(xs) { + if (!xs) { + return [ + 0, + 0 + ]; + } + var match = xs.hd; + var cellX = { + hd: match[0], + tl: 0 + }; + var cellY = { + hd: match[1], + tl: 0 + }; + splitAux(xs.tl, cellX, cellY); + return [ + cellX, + cellY + ]; + } + function zip(l1, l2) { + if (!l1) { + return 0; + } + if (!l2) { + return 0; + } + var cell = { + hd: [ + l1.hd, + l2.hd + ], + tl: 0 + }; + zipAux(l1.tl, l2.tl, cell); + return cell; + } + var size = length; + var filter = keep; + var filterWithIndex = keepWithIndex; + exports.length = length; + exports.size = size; + exports.head = head; + exports.headExn = headExn; + exports.tail = tail; + exports.tailExn = tailExn; + exports.add = add; + exports.get = get; + exports.getExn = getExn; + exports.make = make; + exports.makeByU = makeByU; + exports.makeBy = makeBy; + exports.shuffle = shuffle; + exports.drop = drop; + exports.take = take; + exports.splitAt = splitAt; + exports.concat = concat; + exports.concatMany = concatMany; + exports.reverseConcat = reverseConcat; + exports.flatten = flatten; + exports.mapU = mapU; + exports.map = map; + exports.zip = zip; + exports.zipByU = zipByU; + exports.zipBy = zipBy; + exports.mapWithIndexU = mapWithIndexU; + exports.mapWithIndex = mapWithIndex; + exports.fromArray = fromArray; + exports.toArray = toArray; + exports.reverse = reverse; + exports.mapReverseU = mapReverseU; + exports.mapReverse = mapReverse; + exports.forEachU = forEachU; + exports.forEach = forEach; + exports.forEachWithIndexU = forEachWithIndexU; + exports.forEachWithIndex = forEachWithIndex; + exports.reduceU = reduceU; + exports.reduce = reduce; + exports.reduceWithIndexU = reduceWithIndexU; + exports.reduceWithIndex = reduceWithIndex; + exports.reduceReverseU = reduceReverseU; + exports.reduceReverse = reduceReverse; + exports.mapReverse2U = mapReverse2U; + exports.mapReverse2 = mapReverse2; + exports.forEach2U = forEach2U; + exports.forEach2 = forEach2; + exports.reduce2U = reduce2U; + exports.reduce2 = reduce2; + exports.reduceReverse2U = reduceReverse2U; + exports.reduceReverse2 = reduceReverse2; + exports.everyU = everyU; + exports.every = every; + exports.someU = someU; + exports.some = some; + exports.every2U = every2U; + exports.every2 = every2; + exports.some2U = some2U; + exports.some2 = some2; + exports.cmpByLength = cmpByLength; + exports.cmpU = cmpU; + exports.cmp = cmp; + exports.eqU = eqU; + exports.eq = eq; + exports.hasU = hasU; + exports.has = has; + exports.getByU = getByU; + exports.getBy = getBy; + exports.keepU = keepU; + exports.keep = keep; + exports.filter = filter; + exports.keepWithIndexU = keepWithIndexU; + exports.keepWithIndex = keepWithIndex; + exports.filterWithIndex = filterWithIndex; + exports.keepMapU = keepMapU; + exports.keepMap = keepMap; + exports.partitionU = partitionU; + exports.partition = partition; + exports.unzip = unzip; + exports.getAssocU = getAssocU; + exports.getAssoc = getAssoc; + exports.hasAssocU = hasAssocU; + exports.hasAssoc = hasAssoc; + exports.removeAssocU = removeAssocU; + exports.removeAssoc = removeAssoc; + exports.setAssocU = setAssocU; + exports.setAssoc = setAssoc; + exports.sortU = sortU; + exports.sort = sort; + }); + + // node_modules/rescript/lib/js/caml_string.js + var require_caml_string = __commonJS((exports) => { + "use strict"; + function get(s, i) { + if (i >= s.length || i < 0) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "index out of bounds", + Error: new Error() + }; + } + return s.codePointAt(i); + } + function make(n, ch) { + return String.fromCharCode(ch).repeat(n); + } + exports.get = get; + exports.make = make; + }); + + // node_modules/rescript/lib/js/string.js + var require_string = __commonJS((exports) => { + "use strict"; + var Caml = require_caml(); + var Bytes = require_bytes(); + var Curry = require_curry(); + var Belt_List = require_belt_List(); + var Caml_string = require_caml_string(); + var Caml_js_exceptions = require_caml_js_exceptions(); + function init(n, f) { + return Bytes.unsafe_to_string(Bytes.init(n, f)); + } + function sub(s, ofs, len) { + return Bytes.unsafe_to_string(Bytes.sub(Bytes.unsafe_of_string(s), ofs, len)); + } + function concat(sep, xs) { + return Belt_List.toArray(xs).join(sep); + } + function iter(f, s) { + for (var i = 0, i_finish = s.length; i < i_finish; ++i) { + Curry._1(f, s.codePointAt(i)); + } + } + function iteri(f, s) { + for (var i = 0, i_finish = s.length; i < i_finish; ++i) { + Curry._2(f, i, s.codePointAt(i)); + } + } + function map(f, s) { + return Bytes.unsafe_to_string(Bytes.map(f, Bytes.unsafe_of_string(s))); + } + function mapi(f, s) { + return Bytes.unsafe_to_string(Bytes.mapi(f, Bytes.unsafe_of_string(s))); + } + function is_space(param) { + if (param > 13 || param < 9) { + return param === 32; + } else { + return param !== 11; + } + } + function trim(s) { + if (s === "" || !(is_space(s.codePointAt(0)) || is_space(s.codePointAt(s.length - 1 | 0)))) { + return s; + } else { + return Bytes.unsafe_to_string(Bytes.trim(Bytes.unsafe_of_string(s))); + } + } + function escaped(s) { + var needs_escape = function(_i) { + while (true) { + var i = _i; + if (i >= s.length) { + return false; + } + var match = s.codePointAt(i); + if (match < 32) { + return true; + } + if (match > 92 || match < 34) { + if (match >= 127) { + return true; + } + _i = i + 1 | 0; + continue; + } + if (match > 91 || match < 35) { + return true; + } + _i = i + 1 | 0; + continue; + } + ; + }; + if (needs_escape(0)) { + return Bytes.unsafe_to_string(Bytes.escaped(Bytes.unsafe_of_string(s))); + } else { + return s; + } + } + function index_rec(s, lim, _i, c) { + while (true) { + var i = _i; + if (i >= lim) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + if (s.codePointAt(i) === c) { + return i; + } + _i = i + 1 | 0; + continue; + } + ; + } + function index(s, c) { + return index_rec(s, s.length, 0, c); + } + function index_rec_opt(s, lim, _i, c) { + while (true) { + var i = _i; + if (i >= lim) { + return; + } + if (s.codePointAt(i) === c) { + return i; + } + _i = i + 1 | 0; + continue; + } + ; + } + function index_opt(s, c) { + return index_rec_opt(s, s.length, 0, c); + } + function index_from(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.index_from / Bytes.index_from", + Error: new Error() + }; + } + return index_rec(s, l, i, c); + } + function index_from_opt(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.index_from_opt / Bytes.index_from_opt", + Error: new Error() + }; + } + return index_rec_opt(s, l, i, c); + } + function rindex_rec(s, _i, c) { + while (true) { + var i = _i; + if (i < 0) { + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + if (s.codePointAt(i) === c) { + return i; + } + _i = i - 1 | 0; + continue; + } + ; + } + function rindex(s, c) { + return rindex_rec(s, s.length - 1 | 0, c); + } + function rindex_from(s, i, c) { + if (i < -1 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rindex_from / Bytes.rindex_from", + Error: new Error() + }; + } + return rindex_rec(s, i, c); + } + function rindex_rec_opt(s, _i, c) { + while (true) { + var i = _i; + if (i < 0) { + return; + } + if (s.codePointAt(i) === c) { + return i; + } + _i = i - 1 | 0; + continue; + } + ; + } + function rindex_opt(s, c) { + return rindex_rec_opt(s, s.length - 1 | 0, c); + } + function rindex_from_opt(s, i, c) { + if (i < -1 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rindex_from_opt / Bytes.rindex_from_opt", + Error: new Error() + }; + } + return rindex_rec_opt(s, i, c); + } + function contains_from(s, i, c) { + var l = s.length; + if (i < 0 || i > l) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.contains_from / Bytes.contains_from", + Error: new Error() + }; + } + try { + index_rec(s, l, i, c); + return true; + } catch (raw_exn) { + var exn = Caml_js_exceptions.internalToOCamlException(raw_exn); + if (exn.RE_EXN_ID === "Not_found") { + return false; + } + throw exn; + } + } + function contains(s, c) { + return contains_from(s, 0, c); + } + function rcontains_from(s, i, c) { + if (i < 0 || i >= s.length) { + throw { + RE_EXN_ID: "Invalid_argument", + _1: "String.rcontains_from / Bytes.rcontains_from", + Error: new Error() + }; + } + try { + rindex_rec(s, i, c); + return true; + } catch (raw_exn) { + var exn = Caml_js_exceptions.internalToOCamlException(raw_exn); + if (exn.RE_EXN_ID === "Not_found") { + return false; + } + throw exn; + } + } + function uppercase_ascii(s) { + return Bytes.unsafe_to_string(Bytes.uppercase_ascii(Bytes.unsafe_of_string(s))); + } + function lowercase_ascii(s) { + return Bytes.unsafe_to_string(Bytes.lowercase_ascii(Bytes.unsafe_of_string(s))); + } + function capitalize_ascii(s) { + return Bytes.unsafe_to_string(Bytes.capitalize_ascii(Bytes.unsafe_of_string(s))); + } + function uncapitalize_ascii(s) { + return Bytes.unsafe_to_string(Bytes.uncapitalize_ascii(Bytes.unsafe_of_string(s))); + } + var compare = Caml.string_compare; + function equal(a, b) { + return a === b; + } + function split_on_char(sep, s) { + var r = 0; + var j = s.length; + for (var i = s.length - 1 | 0; i >= 0; --i) { + if (s.codePointAt(i) === sep) { + r = { + hd: sub(s, i + 1 | 0, (j - i | 0) - 1 | 0), + tl: r + }; + j = i; + } + } + return { + hd: sub(s, 0, j), + tl: r + }; + } + var make = Caml_string.make; + var blit = Bytes.blit_string; + exports.make = make; + exports.init = init; + exports.sub = sub; + exports.blit = blit; + exports.concat = concat; + exports.iter = iter; + exports.iteri = iteri; + exports.map = map; + exports.mapi = mapi; + exports.trim = trim; + exports.escaped = escaped; + exports.index = index; + exports.index_opt = index_opt; + exports.rindex = rindex; + exports.rindex_opt = rindex_opt; + exports.index_from = index_from; + exports.index_from_opt = index_from_opt; + exports.rindex_from = rindex_from; + exports.rindex_from_opt = rindex_from_opt; + exports.contains = contains; + exports.contains_from = contains_from; + exports.rcontains_from = rcontains_from; + exports.uppercase_ascii = uppercase_ascii; + exports.lowercase_ascii = lowercase_ascii; + exports.capitalize_ascii = capitalize_ascii; + exports.uncapitalize_ascii = uncapitalize_ascii; + exports.compare = compare; + exports.equal = equal; + exports.split_on_char = split_on_char; + }); + + // node_modules/rescript/lib/js/caml_splice_call.js + var require_caml_splice_call = __commonJS((exports) => { + "use strict"; + var spliceApply = function(fn, args) { + var i, argLen; + argLen = args.length; + var applied = []; + for (i = 0; i < argLen - 1; ++i) { + applied.push(args[i]); + } + var lastOne = args[argLen - 1]; + for (i = 0; i < lastOne.length; ++i) { + applied.push(lastOne[i]); + } + return fn.apply(null, applied); + }; + var spliceNewApply = function(ctor, args) { + var i, argLen; + argLen = args.length; + var applied = [null]; + for (i = 0; i < argLen - 1; ++i) { + applied.push(args[i]); + } + var lastOne = args[argLen - 1]; + for (i = 0; i < lastOne.length; ++i) { + applied.push(lastOne[i]); + } + var C = Function.prototype.bind.apply(ctor, applied); + return new C(); + }; + var spliceObjApply = function(obj, name, args) { + var i, argLen; + argLen = args.length; + var applied = []; + for (i = 0; i < argLen - 1; ++i) { + applied.push(args[i]); + } + var lastOne = args[argLen - 1]; + for (i = 0; i < lastOne.length; ++i) { + applied.push(lastOne[i]); + } + return obj[name].apply(obj, applied); + }; + exports.spliceApply = spliceApply; + exports.spliceNewApply = spliceNewApply; + exports.spliceObjApply = spliceObjApply; + }); + + // node_modules/rescript/lib/js/js_string.js + var require_js_string = __commonJS((exports) => { + "use strict"; + var Curry = require_curry(); + var Caml_option = require_caml_option(); + var Caml_splice_call = require_caml_splice_call(); + function charAt(arg1, obj) { + return obj.charAt(arg1); + } + function charCodeAt(arg1, obj) { + return obj.charCodeAt(arg1); + } + function codePointAt(arg1, obj) { + return obj.codePointAt(arg1); + } + function concat(arg1, obj) { + return obj.concat(arg1); + } + function concatMany(arg1, obj) { + return Caml_splice_call.spliceObjApply(obj, "concat", [arg1]); + } + function endsWith(arg1, obj) { + return obj.endsWith(arg1); + } + function endsWithFrom(arg1, arg2, obj) { + return obj.endsWith(arg1, arg2); + } + function includes(arg1, obj) { + return obj.includes(arg1); + } + function includesFrom(arg1, arg2, obj) { + return obj.includes(arg1, arg2); + } + function indexOf(arg1, obj) { + return obj.indexOf(arg1); + } + function indexOfFrom(arg1, arg2, obj) { + return obj.indexOf(arg1, arg2); + } + function lastIndexOf(arg1, obj) { + return obj.lastIndexOf(arg1); + } + function lastIndexOfFrom(arg1, arg2, obj) { + return obj.lastIndexOf(arg1, arg2); + } + function localeCompare(arg1, obj) { + return obj.localeCompare(arg1); + } + function match_(arg1, obj) { + return Caml_option.null_to_opt(obj.match(arg1)); + } + function normalizeByForm(arg1, obj) { + return obj.normalize(arg1); + } + function repeat(arg1, obj) { + return obj.repeat(arg1); + } + function replace(arg1, arg2, obj) { + return obj.replace(arg1, arg2); + } + function replaceByRe(arg1, arg2, obj) { + return obj.replace(arg1, arg2); + } + function unsafeReplaceBy0(arg1, arg2, obj) { + return obj.replace(arg1, Curry.__3(arg2)); + } + function unsafeReplaceBy1(arg1, arg2, obj) { + return obj.replace(arg1, Curry.__4(arg2)); + } + function unsafeReplaceBy2(arg1, arg2, obj) { + return obj.replace(arg1, Curry.__5(arg2)); + } + function unsafeReplaceBy3(arg1, arg2, obj) { + return obj.replace(arg1, Curry.__6(arg2)); + } + function search(arg1, obj) { + return obj.search(arg1); + } + function slice(from, to_, obj) { + return obj.slice(from, to_); + } + function sliceToEnd(from, obj) { + return obj.slice(from); + } + function split(arg1, obj) { + return obj.split(arg1); + } + function splitAtMost(arg1, limit, obj) { + return obj.split(arg1, limit); + } + function splitByRe(arg1, obj) { + return obj.split(arg1); + } + function splitByReAtMost(arg1, limit, obj) { + return obj.split(arg1, limit); + } + function startsWith(arg1, obj) { + return obj.startsWith(arg1); + } + function startsWithFrom(arg1, arg2, obj) { + return obj.startsWith(arg1, arg2); + } + function substr(from, obj) { + return obj.substr(from); + } + function substrAtMost(from, length, obj) { + return obj.substr(from, length); + } + function substring(from, to_, obj) { + return obj.substring(from, to_); + } + function substringToEnd(from, obj) { + return obj.substring(from); + } + function anchor(arg1, obj) { + return obj.anchor(arg1); + } + function link(arg1, obj) { + return obj.link(arg1); + } + exports.charAt = charAt; + exports.charCodeAt = charCodeAt; + exports.codePointAt = codePointAt; + exports.concat = concat; + exports.concatMany = concatMany; + exports.endsWith = endsWith; + exports.endsWithFrom = endsWithFrom; + exports.includes = includes; + exports.includesFrom = includesFrom; + exports.indexOf = indexOf; + exports.indexOfFrom = indexOfFrom; + exports.lastIndexOf = lastIndexOf; + exports.lastIndexOfFrom = lastIndexOfFrom; + exports.localeCompare = localeCompare; + exports.match_ = match_; + exports.normalizeByForm = normalizeByForm; + exports.repeat = repeat; + exports.replace = replace; + exports.replaceByRe = replaceByRe; + exports.unsafeReplaceBy0 = unsafeReplaceBy0; + exports.unsafeReplaceBy1 = unsafeReplaceBy1; + exports.unsafeReplaceBy2 = unsafeReplaceBy2; + exports.unsafeReplaceBy3 = unsafeReplaceBy3; + exports.search = search; + exports.slice = slice; + exports.sliceToEnd = sliceToEnd; + exports.split = split; + exports.splitAtMost = splitAtMost; + exports.splitByRe = splitByRe; + exports.splitByReAtMost = splitByReAtMost; + exports.startsWith = startsWith; + exports.startsWithFrom = startsWithFrom; + exports.substr = substr; + exports.substrAtMost = substrAtMost; + exports.substring = substring; + exports.substringToEnd = substringToEnd; + exports.anchor = anchor; + exports.link = link; + }); + + // node_modules/bs-css/src/Css_AtomicTypes.bs.js + var require_Css_AtomicTypes_bs = __commonJS((exports) => { + "use strict"; + var $$String = require_string(); + var Js_string = require_js_string(); + var Belt_Array = require_belt_Array(); + function toString(x) { + if (x === "inherit_") { + return "inherit"; + } else if (x === "unset") { + return "unset"; + } else { + return "initial"; + } + } + var Cascading = { + initial: "initial", + inherit_: "inherit_", + unset: "unset", + toString + }; + function $$var(x) { + return { + NAME: "var", + VAL: x + }; + } + function varDefault(x, $$default) { + return { + NAME: "varDefault", + VAL: [ + x, + $$default + ] + }; + } + function prefix(x) { + if (Js_string.startsWith("--", x)) { + return x; + } else { + return "--" + x; + } + } + function toString$1(x) { + if (x.NAME === "var") { + return "var(" + prefix(x.VAL) + ")"; + } + var match = x.VAL; + return "var(" + prefix(match[0]) + "," + match[1] + ")"; + } + function s(x) { + return { + NAME: "s", + VAL: x + }; + } + function ms(x) { + return { + NAME: "ms", + VAL: x + }; + } + function toString$2(x) { + if (x.NAME === "ms") { + return x.VAL.toString() + "ms"; + } else { + return x.VAL.toString() + "s"; + } + } + var Time = { + s, + ms, + toString: toString$2 + }; + function pct(x) { + return { + NAME: "percent", + VAL: x + }; + } + function toString$3(x) { + return x.VAL.toString() + "%"; + } + var Percentage = { + pct, + toString: toString$3 + }; + function toString$4(x) { + return "url(" + x.VAL + ")"; + } + var Url = { + toString: toString$4 + }; + function ch(x) { + return { + NAME: "ch", + VAL: x + }; + } + function em(x) { + return { + NAME: "em", + VAL: x + }; + } + function ex(x) { + return { + NAME: "ex", + VAL: x + }; + } + function rem(x) { + return { + NAME: "rem", + VAL: x + }; + } + function vh(x) { + return { + NAME: "vh", + VAL: x + }; + } + function vw(x) { + return { + NAME: "vw", + VAL: x + }; + } + function vmin(x) { + return { + NAME: "vmin", + VAL: x + }; + } + function vmax(x) { + return { + NAME: "vmax", + VAL: x + }; + } + function px(x) { + return { + NAME: "px", + VAL: x + }; + } + function pxFloat(x) { + return { + NAME: "pxFloat", + VAL: x + }; + } + function cm(x) { + return { + NAME: "cm", + VAL: x + }; + } + function mm(x) { + return { + NAME: "mm", + VAL: x + }; + } + function inch(x) { + return { + NAME: "inch", + VAL: x + }; + } + function pc(x) { + return { + NAME: "pc", + VAL: x + }; + } + function pt(x) { + return { + NAME: "pt", + VAL: x + }; + } + function toString$5(x) { + if (typeof x !== "object") { + return "0"; + } + var variant = x.NAME; + if (variant === "pxFloat") { + return x.VAL.toString() + "px"; + } + if (variant === "inch") { + return x.VAL.toString() + "in"; + } + if (variant === "vmax") { + return x.VAL.toString() + "vmax"; + } + if (variant === "vmin") { + return x.VAL.toString() + "vmin"; + } + if (variant === "percent") { + return x.VAL.toString() + "%"; + } + if (variant === "ch") { + return x.VAL.toString() + "ch"; + } + if (variant === "cm") { + return x.VAL.toString() + "cm"; + } + if (variant === "em") { + return x.VAL.toString() + "em"; + } + if (variant === "ex") { + return x.VAL.toString() + "ex"; + } + if (variant === "mm") { + return x.VAL.toString() + "mm"; + } + if (variant === "pc") { + return x.VAL.toString() + "pc"; + } + if (variant === "pt") { + return x.VAL.toString() + "pt"; + } + if (variant === "px") { + return x.VAL.toString() + "px"; + } + if (variant === "vh") { + return x.VAL.toString() + "vh"; + } + if (variant === "vw") { + return x.VAL.toString() + "vw"; + } + if (variant === "rem") { + return x.VAL.toString() + "rem"; + } + var match = x.VAL; + var match$1 = match[0]; + if (match$1 === "add") { + return "calc(" + toString$5(match[1]) + " + " + toString$5(match[2]) + ")"; + } else if (match$1 === "sub") { + return "calc(" + toString$5(match[1]) + " - " + toString$5(match[2]) + ")"; + } else { + return "calc(" + toString$5(match[1]) + " * " + toString$5(match[2]) + ")"; + } + } + var Length = { + ch, + em, + ex, + rem, + vh, + vw, + vmin, + vmax, + px, + pxFloat, + cm, + mm, + inch, + pc, + pt, + zero: "zero", + toString: toString$5 + }; + function deg(x) { + return { + NAME: "deg", + VAL: x + }; + } + function rad(x) { + return { + NAME: "rad", + VAL: x + }; + } + function grad(x) { + return { + NAME: "grad", + VAL: x + }; + } + function turn(x) { + return { + NAME: "turn", + VAL: x + }; + } + function toString$6(x) { + var variant = x.NAME; + if (variant === "turn") { + return x.VAL.toString() + "turn"; + } else if (variant === "deg") { + return x.VAL.toString() + "deg"; + } else if (variant === "rad") { + return x.VAL.toString() + "rad"; + } else { + return x.VAL.toString() + "grad"; + } + } + var Angle = { + deg, + rad, + grad, + turn, + toString: toString$6 + }; + function toString$7(x) { + if (x === "rtl") { + return "rtl"; + } else { + return "ltr"; + } + } + var Direction = { + ltr: "ltr", + rtl: "rtl", + toString: toString$7 + }; + function toString$8(x) { + if (x === "fixed") { + return "fixed"; + } else if (x === "static") { + return "static"; + } else if (x === "sticky") { + return "sticky"; + } else if (x === "relative") { + return "relative"; + } else { + return "absolute"; + } + } + var Position = { + absolute: "absolute", + relative: "relative", + $$static: "static", + fixed: "fixed", + sticky: "sticky", + toString: toString$8 + }; + function toString$9(x) { + if (x === "isolate") { + return "isolate"; + } else { + return "auto"; + } + } + var Isolation = { + toString: toString$9 + }; + function toString$10(x) { + if (x === "none") { + return "none"; + } else if (x === "vertical") { + return "vertical"; + } else if (x === "horizontal") { + return "horizontal"; + } else if (x === "inline") { + return "inline"; + } else if (x === "block") { + return "block"; + } else { + return "both"; + } + } + var Resize = { + none: "none", + both: "both", + horizontal: "horizontal", + vertical: "vertical", + block: "block", + inline: "inline", + toString: toString$10 + }; + function toString$11(x) { + if (x === "normal") { + return "normal"; + } else { + return "smallCaps"; + } + } + var FontVariant = { + normal: "normal", + smallCaps: "smallCaps", + toString: toString$11 + }; + function toString$12(x) { + if (x === "oblique") { + return "oblique"; + } else if (x === "normal") { + return "normal"; + } else { + return "italic"; + } + } + var FontStyle = { + normal: "normal", + italic: "italic", + oblique: "oblique", + toString: toString$12 + }; + function toString$13(x) { + if (x === "fill") { + return "fill"; + } else if (x === "minContent") { + return "min-content"; + } else if (x === "fitContent") { + return "fit-content"; + } else if (x === "maxContent") { + return "max-content"; + } else if (x === "content") { + return "content"; + } else { + return "auto"; + } + } + var FlexBasis = { + fill: "fill", + content: "content", + maxContent: "maxContent", + minContent: "minContent", + fitContent: "fitContent", + toString: toString$13 + }; + function toString$14(x) { + if (x === "clip") { + return "clip"; + } else if (x === "scroll") { + return "scroll"; + } else if (x === "hidden") { + return "hidden"; + } else if (x === "visible") { + return "visible"; + } else { + return "auto"; + } + } + var Overflow = { + hidden: "hidden", + visible: "visible", + scroll: "scroll", + auto: "auto", + clip: "clip", + toString: toString$14 + }; + function toString$15(x) { + return "auto"; + } + var Margin = { + auto: "auto", + toString: toString$15 + }; + function toString$16(x) { + if (x === "columnDense") { + return "column dense"; + } else if (x === "rowDense") { + return "row dense"; + } else if (x === "row") { + return "row"; + } else { + return "column"; + } + } + var GridAutoFlow = { + toString: toString$16 + }; + function toString$17(x) { + return "normal"; + } + var Gap = { + toString: toString$17 + }; + function toString$18(x) { + if (x === "smooth") { + return "smooth"; + } else { + return "auto"; + } + } + var ScrollBehavior = { + toString: toString$18 + }; + function toString$19(x) { + if (x === "none") { + return "none"; + } else if (x === "contain") { + return "contain"; + } else { + return "auto"; + } + } + var OverscrollBehavior = { + toString: toString$19 + }; + function toString$20(x) { + if (x === "none") { + return "none"; + } else { + return "auto"; + } + } + var OverflowAnchor = { + toString: toString$20 + }; + function toString$21(x) { + return "auto"; + } + var ColumnWidth = { + toString: toString$21 + }; + function toString$22(x) { + return "auto"; + } + var CaretColor = { + toString: toString$22 + }; + function toString$23(x) { + if (x === "bottom") { + return "bottom"; + } else if (x === "sub") { + return "sub"; + } else if (x === "top") { + return "top"; + } else if (x === "super") { + return "super"; + } else if (x === "baseline") { + return "baseline"; + } else if (x === "textBottom") { + return "text-bottom"; + } else if (x === "textTop") { + return "text-top"; + } else { + return "middle"; + } + } + var VerticalAlign = { + toString: toString$23 + }; + function steps(i, dir) { + return { + NAME: "steps", + VAL: [ + i, + dir + ] + }; + } + function cubicBezier(a, b, c, d) { + return { + NAME: "cubicBezier", + VAL: [ + a, + b, + c, + d + ] + }; + } + function toString$24(x) { + if (typeof x !== "object") { + if (x === "easeInOut") { + return "ease-in-out"; + } else if (x === "linear") { + return "linear"; + } else if (x === "jumpBoth") { + return "jump-both"; + } else if (x === "stepStart") { + return "step-start"; + } else if (x === "jumpNone") { + return "jump-none"; + } else if (x === "stepEnd") { + return "step-end"; + } else if (x === "easeIn") { + return "ease-in"; + } else if (x === "jumpEnd") { + return "jump-end"; + } else if (x === "jumpStart") { + return "jump-start"; + } else if (x === "easeOut") { + return "ease-out"; + } else { + return "ease"; + } + } + if (x.NAME === "steps") { + var match = x.VAL; + var i = match[0]; + if (match[1] === "start") { + return "steps(" + i.toString() + ", start)"; + } else { + return "steps(" + i.toString() + ", end)"; + } + } + var match$1 = x.VAL; + return "cubic-bezier(" + match$1[0].toString() + ", " + match$1[1].toString() + ", " + match$1[2].toString() + ", " + match$1[3].toString() + ")"; + } + function toString$25(x) { + if (typeof x === "object") { + return x.VAL.toString(); + } else if (x === "autoFill") { + return "auto-fill"; + } else { + return "auto-fit"; + } + } + var RepeatValue = { + toString: toString$25 + }; + function toString$26(x) { + if (x === "none") { + return "none"; + } else if (x === "circle") { + return "circle"; + } else if (x === "lowerGreek") { + return "lower-greek"; + } else if (x === "square") { + return "square"; + } else if (x === "lowerAlpha") { + return "lower-alpha"; + } else if (x === "upperAlpha") { + return "upper-alpha"; + } else if (x === "decimal") { + return "decimal"; + } else if (x === "lowerRoman") { + return "lower-roman"; + } else if (x === "lowerLatin") { + return "lower-latin"; + } else if (x === "upperRoman") { + return "upper-roman"; + } else if (x === "upperLatin") { + return "upper-latin"; + } else { + return "disc"; + } + } + var ListStyleType = { + toString: toString$26 + }; + function toString$27(x) { + if (x === "inside") { + return "inside"; + } else { + return "outside"; + } + } + var ListStylePosition = { + toString: toString$27 + }; + function toString$28(x) { + if (x === "hidden") { + return "hidden"; + } else if (x === "ridge") { + return "ridge"; + } else if (x === "solid") { + return "solid"; + } else if (x === "outset") { + return "outset"; + } else if (x === "groove") { + return "grove"; + } else if (x === "dashed") { + return "dashed"; + } else if (x === "dotted") { + return "dotted"; + } else if (x === "double") { + return "double"; + } else if (x === "inset") { + return "inset"; + } else { + return "none"; + } + } + var OutlineStyle = { + toString: toString$28 + }; + function toString$29(x) { + if (typeof x === "object") { + return x.VAL.toString(); + } else if (x === "thin") { + return "100"; + } else if (x === "semiBold") { + return "600"; + } else if (x === "bolder") { + return "bolder"; + } else if (x === "light") { + return "300"; + } else if (x === "extraBold") { + return "800"; + } else if (x === "extraLight") { + return "200"; + } else if (x === "medium") { + return "500"; + } else if (x === "lighter") { + return "lighter"; + } else if (x === "normal") { + return "400"; + } else if (x === "black") { + return "900"; + } else { + return "700"; + } + } + var FontWeight = { + thin: "thin", + extraLight: "extraLight", + light: "light", + medium: "medium", + semiBold: "semiBold", + bold: "bold", + extraBold: "extraBold", + lighter: "lighter", + bolder: "bolder", + toString: toString$29 + }; + function translate(x, y) { + return { + NAME: "translate", + VAL: [ + x, + y + ] + }; + } + function translate3d(x, y, z) { + return { + NAME: "translate3d", + VAL: [ + x, + y, + z + ] + }; + } + function translateX(x) { + return { + NAME: "translateX", + VAL: x + }; + } + function translateY(y) { + return { + NAME: "translateY", + VAL: y + }; + } + function translateZ(z) { + return { + NAME: "translateZ", + VAL: z + }; + } + function scale(x, y) { + return { + NAME: "scale", + VAL: [ + x, + y + ] + }; + } + function scale3d(x, y, z) { + return { + NAME: "scale3d", + VAL: [ + x, + y, + z + ] + }; + } + function scaleX(x) { + return { + NAME: "scaleX", + VAL: x + }; + } + function scaleY(x) { + return { + NAME: "scaleY", + VAL: x + }; + } + function scaleZ(x) { + return { + NAME: "scaleZ", + VAL: x + }; + } + function rotate(a) { + return { + NAME: "rotate", + VAL: a + }; + } + function rotate3d(x, y, z, a) { + return { + NAME: "rotate3d", + VAL: [ + x, + y, + z, + a + ] + }; + } + function rotateX(a) { + return { + NAME: "rotateX", + VAL: a + }; + } + function rotateY(a) { + return { + NAME: "rotateY", + VAL: a + }; + } + function rotateZ(a) { + return { + NAME: "rotateZ", + VAL: a + }; + } + function skew(a, a$p) { + return { + NAME: "skew", + VAL: [ + a, + a$p + ] + }; + } + function skewX(a) { + return { + NAME: "skewX", + VAL: a + }; + } + function skewY(a) { + return { + NAME: "skewY", + VAL: a + }; + } + function toString$30(x) { + var variant = x.NAME; + if (variant === "translate") { + var match = x.VAL; + return "translate(" + toString$5(match[0]) + ", " + toString$5(match[1]) + ")"; + } + if (variant === "rotate") { + return "rotate(" + toString$6(x.VAL) + ")"; + } + if (variant === "skew") { + var match$1 = x.VAL; + return "skew(" + toString$6(match$1[0]) + ", " + toString$6(match$1[1]) + ")"; + } + if (variant === "scale3d") { + var match$2 = x.VAL; + return "scale3d(" + match$2[0].toString() + ", " + match$2[1].toString() + ", " + match$2[2].toString() + ")"; + } + if (variant === "rotateX") { + return "rotateX(" + toString$6(x.VAL) + ")"; + } + if (variant === "rotateY") { + return "rotateY(" + toString$6(x.VAL) + ")"; + } + if (variant === "rotateZ") { + return "rotateZ(" + toString$6(x.VAL) + ")"; + } + if (variant === "scale") { + var match$3 = x.VAL; + var x$1 = match$3[0]; + var y = match$3[1]; + return "scale(" + x$1.toString() + ", " + y.toString() + ")"; + } + if (variant === "skewX") { + return "skewX(" + toString$6(x.VAL) + ")"; + } + if (variant === "skewY") { + return "skewY(" + toString$6(x.VAL) + ")"; + } + if (variant === "translateX") { + return "translateX(" + toString$5(x.VAL) + ")"; + } + if (variant === "translateY") { + return "translateY(" + toString$5(x.VAL) + ")"; + } + if (variant === "translateZ") { + return "translateZ(" + toString$5(x.VAL) + ")"; + } + if (variant === "rotate3d") { + var match$4 = x.VAL; + return "rotate3d(" + match$4[0].toString() + ", " + match$4[1].toString() + ", " + match$4[2].toString() + ", " + toString$6(match$4[3]) + ")"; + } + if (variant !== "translate3d") { + if (variant === "scaleX") { + return "scaleX(" + x.VAL.toString() + ")"; + } else if (variant === "scaleY") { + return "scaleY(" + x.VAL.toString() + ")"; + } else if (variant === "scaleZ") { + return "scaleZ(" + x.VAL.toString() + ")"; + } else { + return "perspective(" + x.VAL.toString() + ")"; + } + } + var match$5 = x.VAL; + var x$2 = match$5[0]; + var y$1 = match$5[1]; + var z = match$5[2]; + return "translate3d(" + toString$5(x$2) + ", " + toString$5(y$1) + ", " + toString$5(z) + ")"; + } + function toString$31(x) { + if (x === "alternateReverse") { + return "alternate-reverse"; + } else if (x === "normal") { + return "normal"; + } else if (x === "alternate") { + return "alternate"; + } else { + return "reverse"; + } + } + var AnimationDirection = { + toString: toString$31 + }; + function toString$32(x) { + if (x === "none") { + return "none"; + } else if (x === "backwards") { + return "backwards"; + } else if (x === "forwards") { + return "forwards"; + } else { + return "both"; + } + } + var AnimationFillMode = { + toString: toString$32 + }; + function toString$33(x) { + if (typeof x === "object") { + return x.VAL.toString(); + } else { + return "infinite"; + } + } + var AnimationIterationCount = { + toString: toString$33 + }; + function toString$34(x) { + if (x === "paused") { + return "paused"; + } else { + return "running"; + } + } + var AnimationPlayState = { + toString: toString$34 + }; + function toString$35(x) { + if (x === "cell") { + return "cell"; + } else if (x === "copy") { + return "copy"; + } else if (x === "swResize") { + return "sw-resize"; + } else if (x === "grab") { + return "grab"; + } else if (x === "help") { + return "help"; + } else if (x === "move") { + return "move"; + } else if (x === "none") { + return "none"; + } else if (x === "text") { + return "text"; + } else if (x === "rowResize") { + return "row-resize"; + } else if (x === "wait") { + return "wait"; + } else if (x === "pointer") { + return "pointer"; + } else if (x === "seResize") { + return "se-resize"; + } else if (x === "zoomOut") { + return "zoom-out"; + } else if (x === "sResize") { + return "s-resize"; + } else if (x === "zoomIn") { + return "zoom-in"; + } else if (x === "grabbing") { + return "grabbing"; + } else if (x === "nsResize") { + return "ns-resize"; + } else if (x === "nwseResize") { + return "nwse-resize"; + } else if (x === "progress") { + return "progress"; + } else if (x === "crosshair") { + return "crosshair"; + } else if (x === "wResize") { + return "w-resize"; + } else if (x === "noDrop") { + return "no-drop"; + } else if (x === "allScroll") { + return "all-scroll"; + } else if (x === "verticalText") { + return "vertical-text"; + } else if (x === "nResize") { + return "n-resize"; + } else if (x === "default") { + return "default"; + } else if (x === "neswResize") { + return "nesw-resize"; + } else if (x === "alias") { + return "alias"; + } else if (x === "ewResize") { + return "ew-resize"; + } else if (x === "eResize") { + return "e-resize"; + } else if (x === "nwResize") { + return "nw-resize"; + } else if (x === "contextMenu") { + return "context-menu"; + } else if (x === "colResize") { + return "col-resize"; + } else if (x === "notAllowed") { + return "not-allowed"; + } else if (x === "neResize") { + return "ne-resize"; + } else { + return "auto"; + } + } + var Cursor = { + auto: "auto", + $$default: "default", + none: "none", + contextMenu: "contextMenu", + help: "help", + pointer: "pointer", + progress: "progress", + wait: "wait", + cell: "cell", + crosshair: "crosshair", + text: "text", + verticalText: "verticalText", + alias: "alias", + copy: "copy", + move: "move", + noDrop: "noDrop", + notAllowed: "notAllowed", + grab: "grab", + grabbing: "grabbing", + allScroll: "allScroll", + colResize: "colResize", + rowResize: "rowResize", + nResize: "nResize", + eResize: "eResize", + sResize: "sResize", + wResize: "wResize", + neResize: "neResize", + nwResize: "nwResize", + seResize: "seResize", + swResize: "swResize", + ewResize: "ewResize", + nsResize: "nsResize", + neswResize: "neswResize", + nwseResize: "nwseResize", + zoomIn: "zoomIn", + zoomOut: "zoomOut", + toString: toString$35 + }; + function rgb(r, g, b) { + return { + NAME: "rgb", + VAL: [ + r, + g, + b + ] + }; + } + function rgba(r, g, b, a) { + return { + NAME: "rgba", + VAL: [ + r, + g, + b, + a + ] + }; + } + function hsl(h, s2, l) { + return { + NAME: "hsl", + VAL: [ + h, + s2, + l + ] + }; + } + function hsla(h, s2, l, a) { + return { + NAME: "hsla", + VAL: [ + h, + s2, + l, + a + ] + }; + } + function hex(x) { + return { + NAME: "hex", + VAL: x + }; + } + function string_of_alpha(x) { + if (x.NAME === "num") { + return x.VAL.toString(); + } else { + return toString$3(x); + } + } + function toString$36(x) { + if (typeof x !== "object") { + if (x === "transparent") { + return "transparent"; + } else { + return "currentColor"; + } + } + var variant = x.NAME; + if (variant === "rgba") { + var match = x.VAL; + return "rgba(" + match[0].toString() + ", " + match[1].toString() + ", " + match[2].toString() + ", " + string_of_alpha(match[3]) + ")"; + } + if (variant === "hex") { + return "#" + x.VAL; + } + if (variant === "hsl") { + var match$1 = x.VAL; + return "hsl(" + toString$6(match$1[0]) + ", " + toString$3(match$1[1]) + ", " + toString$3(match$1[2]) + ")"; + } + if (variant === "rgb") { + var match$2 = x.VAL; + return "rgb(" + match$2[0].toString() + ", " + match$2[1].toString() + ", " + match$2[2].toString() + ")"; + } + var match$3 = x.VAL; + return "hsla(" + toString$6(match$3[0]) + ", " + toString$3(match$3[1]) + ", " + toString$3(match$3[2]) + ", " + string_of_alpha(match$3[3]) + ")"; + } + function toString$37(x) { + if (x === "hidden") { + return "hidden"; + } else if (x === "ridge") { + return "ridge"; + } else if (x === "solid") { + return "solid"; + } else if (x === "outset") { + return "outset"; + } else if (x === "groove") { + return "groove"; + } else if (x === "dashed") { + return "dashed"; + } else if (x === "dotted") { + return "dotted"; + } else if (x === "double") { + return "double"; + } else if (x === "inset") { + return "inset"; + } else { + return "none"; + } + } + var BorderStyle = { + toString: toString$37 + }; + function toString$38(x) { + if (x === "none") { + return "none"; + } else { + return "auto"; + } + } + var PointerEvents = { + toString: toString$38 + }; + function toString$39(x) { + return "none"; + } + var Perspective = { + toString: toString$39 + }; + function toString$40(x) { + return "normal"; + } + var LetterSpacing = { + normal: "normal", + toString: toString$40 + }; + function toString$41(x) { + if (typeof x === "object") { + return x.VAL.toString(); + } else { + return "normal"; + } + } + var LineHeight = { + toString: toString$41 + }; + function toString$42(x) { + return "normal"; + } + var WordSpacing = { + toString: toString$42 + }; + function toString$43(x) { + if (x === "inline") { + return "inline"; + } else if (x === "block") { + return "block"; + } else { + return "run-in"; + } + } + var DisplayOutside = { + toString: toString$43 + }; + function toString$44(x) { + if (x === "grid") { + return "grid"; + } else if (x === "table") { + return "table"; + } else { + return "flex"; + } + } + var DisplayInside = { + toString: toString$44 + }; + function toString$45(x) { + return "list-item"; + } + var DisplayListItem = { + toString: toString$45 + }; + function toString$46(x) { + if (x === "tableRow") { + return "table-row"; + } else if (x === "tableRowGroup") { + return "table-row-group"; + } else if (x === "tableColumn") { + return "table-column"; + } else if (x === "tableHeaderGroup") { + return "table-header-group"; + } else if (x === "tableCell") { + return "table-cell"; + } else if (x === "tableColumnGroup") { + return "table-column-group"; + } else if (x === "tableCaption") { + return "table-caption"; + } else { + return "table-footer-group"; + } + } + var DisplayInternal = { + toString: toString$46 + }; + function toString$47(x) { + if (x === "contents") { + return "contents"; + } else { + return "none"; + } + } + var DisplayBox = { + toString: toString$47 + }; + function toString$48(x) { + if (x === "inlineBlock") { + return "inline-block"; + } else if (x === "inlineFlex") { + return "inline-flex"; + } else if (x === "inlineGrid") { + return "inline-grid"; + } else { + return "inline-table"; + } + } + var DisplayLegacy = { + toString: toString$48 + }; + function toString$49(x) { + if (x === "stretch") { + return "stretch"; + } else if (x === "normal") { + return "normal"; + } else { + return "auto"; + } + } + var JustifySelf = { + toString: toString$49 + }; + function toString$50(x) { + if (x === "left") { + return "left"; + } else if (x === "right") { + return "right"; + } else if (x === "selfEnd") { + return "self-end"; + } else if (x === "start") { + return "start"; + } else if (x === "center") { + return "center"; + } else if (x === "flexStart") { + return "flex-start"; + } else if (x === "flexEnd") { + return "flex-end"; + } else if (x === "selfStart") { + return "self-start"; + } else { + return "end"; + } + } + var PositionalAlignment = { + toString: toString$50 + }; + function toString$51(x) { + if (x.NAME === "unsafe") { + return "unsafe " + toString$50(x.VAL); + } else { + return "safe " + toString$50(x.VAL); + } + } + var OverflowAlignment = { + toString: toString$51 + }; + function toString$52(x) { + if (x === "firstBaseline") { + return "first baseline"; + } else if (x === "baseline") { + return "baseline"; + } else { + return "last baseline"; + } + } + var BaselineAlignment = { + toString: toString$52 + }; + function toString$53(x) { + return "normal"; + } + var NormalAlignment = { + toString: toString$53 + }; + function toString$54(x) { + if (x === "spaceAround") { + return "space-around"; + } else if (x === "stretch") { + return "stretch"; + } else if (x === "spaceBetween") { + return "space-between"; + } else { + return "space-evenly"; + } + } + var DistributedAlignment = { + toString: toString$54 + }; + function toString$55(x) { + if (x === "legacyLeft") { + return "legacy left"; + } else if (x === "legacy") { + return "legacy"; + } else if (x === "legacyRight") { + return "legacy right"; + } else { + return "legacy center"; + } + } + var LegacyAlignment = { + toString: toString$55 + }; + function toString$56(x) { + if (x === "right") { + return "right"; + } else if (x === "justify") { + return "justify"; + } else if (x === "start") { + return "start"; + } else if (x === "center") { + return "center"; + } else { + return "left"; + } + } + var TextAlign = { + toString: toString$56 + }; + function toString$57(x) { + if (x === "normal") { + return "normal"; + } else if (x === "keepAll") { + return "keep-all"; + } else { + return "break-all"; + } + } + var WordBreak = { + toString: toString$57 + }; + function toString$58(x) { + if (x === "preLine") { + return "pre-line"; + } else if (x === "preWrap") { + return "pre-wrap"; + } else if (x === "breakSpaces") { + return "break-spaces"; + } else if (x === "normal") { + return "normal"; + } else if (x === "nowrap") { + return "nowrap"; + } else { + return "pre"; + } + } + var WhiteSpace = { + toString: toString$58 + }; + function toString$59(x) { + if (x === "normal") { + return "normal"; + } else { + return "stretch"; + } + } + var AlignItems = { + toString: toString$59 + }; + function toString$60(x) { + if (x === "stretch") { + return "stretch"; + } else if (x === "normal") { + return "normal"; + } else { + return "auto"; + } + } + var AlignSelf = { + toString: toString$60 + }; + function toString$61(x) { + if (x === "start") { + return "start"; + } else if (x === "center") { + return "center"; + } else if (x === "flexStart") { + return "flex-start"; + } else if (x === "flexEnd") { + return "flex-end"; + } else { + return "end"; + } + } + var AlignContent = { + toString: toString$61 + }; + function toString$62(x) { + if (x === "none") { + return "none"; + } else if (x === "cover") { + return "cover"; + } else if (x === "contain") { + return "contain"; + } else if (x === "scaleDown") { + return "scale-down"; + } else { + return "fill"; + } + } + var ObjectFit = { + toString: toString$62 + }; + function toString$63(x) { + if (x === "inlineStart") { + return "inline-start"; + } else if (x === "left") { + return "left"; + } else if (x === "none") { + return "none"; + } else if (x === "right") { + return "right"; + } else if (x === "inlineEnd") { + return "inline-end"; + } else { + return "both"; + } + } + var Clear = { + toString: toString$63 + }; + function toString$64(x) { + if (x === "left") { + return "left"; + } else if (x === "none") { + return "none"; + } else if (x === "right") { + return "right"; + } else if (x === "inlineEnd") { + return "inline-end"; + } else { + return "inline-start"; + } + } + var Float = { + toString: toString$64 + }; + function toString$65(x) { + if (x === "hidden") { + return "hidden"; + } else if (x === "visible") { + return "visible"; + } else { + return "collapse"; + } + } + var Visibility = { + toString: toString$65 + }; + function toString$66(x) { + if (x === "fixed") { + return "fixed"; + } else { + return "auto"; + } + } + var TableLayout = { + toString: toString$66 + }; + function toString$67(x) { + if (x === "separate") { + return "separate"; + } else { + return "collapse"; + } + } + var BorderCollapse = { + toString: toString$67 + }; + function toString$68(x) { + if (x === "wrapReverse") { + return "wrap-reverse"; + } else if (x === "nowrap") { + return "nowrap"; + } else { + return "wrap"; + } + } + var FlexWrap = { + toString: toString$68 + }; + function toString$69(x) { + if (x === "row") { + return "row"; + } else if (x === "columnReverse") { + return "column-reverse"; + } else if (x === "rowReverse") { + return "row-reverse"; + } else { + return "column"; + } + } + var FlexDirection = { + toString: toString$69 + }; + function toString$70(x) { + if (x === "borderBox") { + return "border-box"; + } else { + return "content-box"; + } + } + var BoxSizing = { + toString: toString$70 + }; + function toString$71(x) { + if (typeof x === "object") { + return x.VAL.toString(); + } else { + return "auto"; + } + } + var ColumnCount = { + toString: toString$71 + }; + function toString$72(x) { + if (x === "none") { + return "none"; + } else if (x === "text") { + return "text"; + } else if (x === "all") { + return "all"; + } else if (x === "contain") { + return "contain"; + } else { + return "auto"; + } + } + var UserSelect = { + toString: toString$72 + }; + function toString$73(x) { + if (x === "capitalize") { + return "capitalize"; + } else if (x === "lowercase") { + return "lowercase"; + } else if (x === "uppercase") { + return "uppercase"; + } else { + return "none"; + } + } + var TextTransform = { + toString: toString$73 + }; + function areas(x) { + return { + NAME: "areas", + VAL: x + }; + } + function toString$74(x) { + if (typeof x === "object") { + return $$String.trim(Belt_Array.reduceU(x.VAL, "", function(carry, item) { + return carry + "'" + item + "' "; + })); + } else { + return "none"; + } + } + var GridTemplateAreas = { + areas, + toString: toString$74 + }; + function ident(x) { + return { + NAME: "ident", + VAL: x + }; + } + function num(x) { + return { + NAME: "num", + VAL: x + }; + } + function numIdent(x, y) { + return { + NAME: "numIdent", + VAL: [ + x, + y + ] + }; + } + function span(x) { + return { + NAME: "span", + VAL: x + }; + } + function toString$75(t) { + if (typeof t !== "object") { + return "auto"; + } + var variant = t.NAME; + if (variant === "numIdent") { + var match = t.VAL; + return String(match[0]) + " " + match[1]; + } + if (variant === "num") { + return String(t.VAL); + } + if (variant === "ident") { + return t.VAL; + } + var e = t.VAL; + return "span " + (e.NAME === "ident" ? e.VAL : String(e.VAL)); + } + var GridArea = { + auto: "auto", + ident, + num, + numIdent, + span, + toString: toString$75 + }; + function toString$76(x) { + if (typeof x !== "object") { + return "none"; + } + var variant = x.NAME; + if (variant === "dropShadow") { + var match = x.VAL; + if (match.NAME === "num") { + return "drop-shadow(" + String(match.VAL) + ")"; + } else { + return "drop-shadow(" + (match.VAL.toString() + "%") + ")"; + } + } + if (variant === "brightness") { + var match$1 = x.VAL; + if (match$1.NAME === "num") { + return "brightness(" + String(match$1.VAL) + ")"; + } else { + return "brightness(" + (match$1.VAL.toString() + "%") + ")"; + } + } + if (variant === "opacity") { + var match$2 = x.VAL; + if (match$2.NAME === "num") { + return "opacity(" + String(match$2.VAL) + ")"; + } else { + return "opacity(" + (match$2.VAL.toString() + "%") + ")"; + } + } + if (variant === "grayscale") { + var match$3 = x.VAL; + if (match$3.NAME === "num") { + return "grayscale(" + String(match$3.VAL) + ")"; + } else { + return "grayscale(" + (match$3.VAL.toString() + "%") + ")"; + } + } + if (variant === "sepia") { + var match$4 = x.VAL; + if (match$4.NAME === "num") { + return "sepia(" + String(match$4.VAL) + ")"; + } else { + return "sepia(" + (match$4.VAL.toString() + "%") + ")"; + } + } + if (variant === "saturate") { + var match$5 = x.VAL; + if (match$5.NAME === "num") { + return "saturate(" + String(match$5.VAL) + ")"; + } else { + return "saturate(" + (match$5.VAL.toString() + "%") + ")"; + } + } + if (variant === "invert") { + var match$6 = x.VAL; + if (match$6.NAME === "num") { + return "invert(" + String(match$6.VAL) + ")"; + } else { + return "invert(" + (match$6.VAL.toString() + "%") + ")"; + } + } + if (variant === "contrast") { + var match$7 = x.VAL; + if (match$7.NAME === "num") { + return "contrast(" + String(match$7.VAL) + ")"; + } else { + return "contrast(" + (match$7.VAL.toString() + "%") + ")"; + } + } + if (variant !== "hueRotate") { + return "blur(" + toString$5(x.VAL) + ")"; + } + var h = x.VAL; + if (typeof h === "object") { + return "hue-rotate(" + toString$6(h) + ")"; + } else { + return "hue-rotate(0deg)"; + } + } + function toString$77(x) { + if (x === "local") { + return "local"; + } else if (x === "fixed") { + return "fixed"; + } else { + return "scroll"; + } + } + var BackgroundAttachment = { + toString: toString$77 + }; + function toString$78(x) { + if (x === "borderBox") { + return "border-box"; + } else if (x === "paddingBox") { + return "padding-box"; + } else { + return "content-box"; + } + } + var BackgroundClip = { + toString: toString$78 + }; + function toString$79(x) { + if (x === "borderBox") { + return "border-box"; + } else if (x === "paddingBox") { + return "padding-box"; + } else { + return "content-box"; + } + } + var BackgroundOrigin = { + toString: toString$79 + }; + function toString$80(x) { + if (x === "right") { + return "right"; + } else if (x === "center") { + return "center"; + } else { + return "left"; + } + } + var X = { + toString: toString$80 + }; + function toString$81(x) { + if (x === "top") { + return "top"; + } else if (x === "center") { + return "center"; + } else { + return "bottom"; + } + } + var Y = { + toString: toString$81 + }; + function toString$82(x) { + if (x === "bottom") { + return "bottom"; + } else if (x === "right") { + return "right"; + } else if (x === "top") { + return "top"; + } else if (x === "center") { + return "center"; + } else { + return "left"; + } + } + var BackgroundPosition = { + X, + Y, + toString: toString$82 + }; + function toString$83(x) { + if (x === "right") { + return "right"; + } else if (x === "center") { + return "center"; + } else { + return "left"; + } + } + var X$1 = { + toString: toString$83 + }; + function toString$84(x) { + if (x === "top") { + return "top"; + } else if (x === "center") { + return "center"; + } else { + return "bottom"; + } + } + var Y$1 = { + toString: toString$84 + }; + function toString$85(x) { + if (x === "bottom") { + return "bottom"; + } else if (x === "right") { + return "right"; + } else if (x === "top") { + return "top"; + } else if (x === "center") { + return "center"; + } else { + return "left"; + } + } + var MaskPosition = { + X: X$1, + Y: Y$1, + toString: toString$85 + }; + function toString$86(x) { + if (x === "round") { + return "round"; + } else if (x === "space") { + return "space"; + } else if (x === "repeat") { + return "repeat"; + } else if (x === "repeatX") { + return "repeat-x"; + } else if (x === "repeatY") { + return "repeat-y"; + } else { + return "no-repeat"; + } + } + var BackgroundRepeat = { + toString: toString$86 + }; + function toString$87(x) { + if (typeof x === "object") { + return x.VAL; + } else if (x === "ellipsis") { + return "ellipsis"; + } else { + return "clip"; + } + } + var TextOverflow = { + toString: toString$87 + }; + function toString$88(x) { + if (x === "none") { + return "none"; + } else if (x === "underline") { + return "underline"; + } else if (x === "lineThrough") { + return "line-through"; + } else if (x === "blink") { + return "blink"; + } else { + return "overline"; + } + } + var TextDecorationLine = { + toString: toString$88 + }; + function toString$89(x) { + if (x === "solid") { + return "solid"; + } else if (x === "dashed") { + return "dashed"; + } else if (x === "dotted") { + return "dotted"; + } else if (x === "double") { + return "double"; + } else { + return "wavy"; + } + } + var TextDecorationStyle = { + toString: toString$89 + }; + function toString$90(x) { + if (x === "fromFont") { + return "from-font"; + } else { + return "auto"; + } + } + var TextDecorationThickness = { + toString: toString$90 + }; + function toString$91(x) { + if (x === "minContent") { + return "min-content"; + } else if (x === "fitContent") { + return "fit-content"; + } else if (x === "maxContent") { + return "max-content"; + } else { + return "auto"; + } + } + var Width = { + toString: toString$91 + }; + function toString$92(x) { + return "none"; + } + var None = { + toString: toString$92 + }; + function toString$93(x) { + if (x === "minContent") { + return "min-content"; + } else if (x === "fitContent") { + return "fit-content"; + } else if (x === "maxContent") { + return "max-content"; + } else { + return "auto"; + } + } + var Height = { + toString: toString$93 + }; + function toString$94(x) { + if (x === "anywhere") { + return "anywhere"; + } else if (x === "breakWord") { + return "break-word"; + } else { + return "normal"; + } + } + var OverflowWrap = { + toString: toString$94 + }; + function linearGradient(angle, stops) { + return { + NAME: "linearGradient", + VAL: [ + angle, + stops + ] + }; + } + function repeatingLinearGradient(angle, stops) { + return { + NAME: "repeatingLinearGradient", + VAL: [ + angle, + stops + ] + }; + } + function radialGradient(stops) { + return { + NAME: "radialGradient", + VAL: stops + }; + } + function repeatingRadialGradient(stops) { + return { + NAME: "repeatingRadialGradient", + VAL: stops + }; + } + function conicGradient(angle, stops) { + return { + NAME: "conicGradient", + VAL: [ + angle, + stops + ] + }; + } + function string_of_color(x) { + if (typeof x !== "object") { + return toString$36(x); + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return toString$1(x); + } else { + return toString$36(x); + } + } + function string_of_stops(stops) { + return Belt_Array.map(stops, function(param) { + return string_of_color(param[1]) + " " + toString$5(param[0]); + }).join(", "); + } + function toString$95(x) { + var variant = x.NAME; + if (variant === "repeatingRadialGradient") { + return "repeating-radial-gradient(" + string_of_stops(x.VAL) + ")"; + } + if (variant === "repeatingLinearGradient") { + var match = x.VAL; + return "repeating-linear-gradient(" + toString$6(match[0]) + ", " + string_of_stops(match[1]) + ")"; + } + if (variant === "radialGradient") { + return "radial-gradient(" + string_of_stops(x.VAL) + ")"; + } + if (variant === "linearGradient") { + var match$1 = x.VAL; + return "linear-gradient(" + toString$6(match$1[0]) + ", " + string_of_stops(match$1[1]) + ")"; + } + var match$2 = x.VAL; + return "conic-gradient(from " + toString$6(match$2[0]) + ", " + string_of_stops(match$2[1]) + ")"; + } + function toString$96(x) { + return "none"; + } + var BackgroundImage = { + toString: toString$96 + }; + function toString$97(x) { + return "none"; + } + var MaskImage = { + toString: toString$97 + }; + function toString$98(x) { + if (x === "marginBox") { + return "margin-box"; + } else if (x === "strokeBox") { + return "stroke-box"; + } else if (x === "borderBox") { + return "border-box"; + } else if (x === "fillBox") { + return "fill-box"; + } else if (x === "viewBox") { + return "view-box"; + } else if (x === "paddingBox") { + return "padding-box"; + } else { + return "content-box"; + } + } + var GeometryBox = { + marginBox: "marginBox", + borderBox: "borderBox", + paddingBox: "paddingBox", + contentBox: "contentBox", + fillBox: "fillBox", + strokeBox: "strokeBox", + viewBox: "viewBox", + toString: toString$98 + }; + function toString$99(x) { + return "none"; + } + var ClipPath = { + toString: toString$99 + }; + function toString$100(x) { + if (x === "visible") { + return "visible"; + } else { + return "hidden"; + } + } + var BackfaceVisibility = { + toString: toString$100 + }; + function toString$101(x) { + if (x === "none") { + return "none"; + } else if (x === "initial") { + return "initial"; + } else { + return "auto"; + } + } + var Flex = { + toString: toString$101 + }; + function toString$102(x) { + if (x === "preserve3d") { + return "preserve-3d"; + } else { + return "flat"; + } + } + var TransformStyle = { + toString: toString$102 + }; + function toString$103(x) { + if (x === "strokeBox") { + return "stroke-box"; + } else if (x === "borderBox") { + return "border-box"; + } else if (x === "fillBox") { + return "fill-box"; + } else if (x === "viewBox") { + return "view-box"; + } else { + return "content-box"; + } + } + var TransformBox = { + toString: toString$103 + }; + function toString$104(x) { + return "none"; + } + var ListStyleImage = { + toString: toString$104 + }; + function toString$105(x) { + if (typeof x === "object") { + return x.VAL; + } else if (x === "cursive") { + return "cursive"; + } else if (x === "sansSerif") { + return "sans-serif"; + } else if (x === "monospace") { + return "monospace"; + } else if (x === "systemUi") { + return "system-ui"; + } else if (x === "emoji") { + return "emoji"; + } else if (x === "serif") { + return "serif"; + } else if (x === "fantasy") { + return "fantasy"; + } else if (x === "fangsong") { + return "fangsong"; + } else { + return "math"; + } + } + function toString$106(x) { + if (x === "swap") { + return "swap"; + } else if (x === "optional") { + return "optional"; + } else if (x === "fallback") { + return "fallback"; + } else if (x === "block") { + return "block"; + } else { + return "auto"; + } + } + var toString$107 = toString$26; + var CounterStyleType = { + toString: toString$107 + }; + function counter(styleOpt, name) { + var style = styleOpt !== void 0 ? styleOpt : "unset"; + return { + NAME: "counter", + VAL: [ + name, + style + ] + }; + } + function toString$108(x) { + var match = x.VAL; + var style = match[1]; + var counter2 = match[0]; + if (style === "unset") { + return "counter(" + counter2 + ")"; + } else { + return "counter(" + counter2 + "," + toString$26(style) + ")"; + } + } + var Counter = { + counter, + toString: toString$108 + }; + function counters(styleOpt, separatorOpt, name) { + var style = styleOpt !== void 0 ? styleOpt : "unset"; + var separator = separatorOpt !== void 0 ? separatorOpt : ""; + return { + NAME: "counters", + VAL: [ + name, + separator, + style + ] + }; + } + function toString$109(x) { + var match = x.VAL; + var style = match[2]; + var separator = match[1]; + var name = match[0]; + if (style === "unset") { + return "counters(" + name + ',"' + separator + '")'; + } else { + return "counters(" + name + ',"' + separator + '",' + toString$26(style) + ")"; + } + } + var Counters = { + counters, + toString: toString$109 + }; + function increment(valueOpt, name) { + var value = valueOpt !== void 0 ? valueOpt : 1; + return { + NAME: "increment", + VAL: [ + name, + value + ] + }; + } + function toString$110(x) { + if (typeof x !== "object") { + return "none"; + } + var match = x.VAL; + return match[0] + " " + String(match[1]); + } + var CounterIncrement = { + increment, + toString: toString$110 + }; + function reset(valueOpt, name) { + var value = valueOpt !== void 0 ? valueOpt : 0; + return { + NAME: "reset", + VAL: [ + name, + value + ] + }; + } + function toString$111(x) { + if (typeof x !== "object") { + return "none"; + } + var match = x.VAL; + return match[0] + " " + String(match[1]); + } + var CounterReset = { + reset, + toString: toString$111 + }; + function set(valueOpt, name) { + var value = valueOpt !== void 0 ? valueOpt : 0; + return { + NAME: "set", + VAL: [ + name, + value + ] + }; + } + function toString$112(x) { + if (typeof x !== "object") { + return "none"; + } + var match = x.VAL; + return match[0] + " " + String(match[1]); + } + var CounterSet = { + set, + toString: toString$112 + }; + function toString$113(x) { + if (typeof x === "object") { + if (x.NAME === "text") { + return x.VAL; + } else { + return "attr(" + x.VAL + ")"; + } + } else if (x === "none") { + return "none"; + } else if (x === "openQuote") { + return "open-quote"; + } else if (x === "closeQuote") { + return "close-quote"; + } else if (x === "normal") { + return "normal"; + } else if (x === "noOpenQuote") { + return "no-open-quote"; + } else { + return "no-close-quote"; + } + } + var Content = { + toString: toString$113 + }; + function toString$114(x) { + if (x === "contextFill") { + return "context-fill"; + } else if (x === "contextStroke") { + return "context-stroke"; + } else { + return "none"; + } + } + var Fill = { + contextFill: "contextFill", + contextStroke: "contextStroke", + toString: toString$114 + }; + var SVG = { + Fill + }; + function toString$115(x) { + if (x === "none") { + return "none"; + } else if (x === "panX") { + return "pan-x"; + } else if (x === "panY") { + return "pan-y"; + } else if (x === "pinchZoom") { + return "pinch-zoom"; + } else if (x === "manipulation") { + return "manipulation"; + } else if (x === "panDown") { + return "pan-down"; + } else if (x === "panLeft") { + return "pan-left"; + } else if (x === "panUp") { + return "pan-up"; + } else if (x === "panRight") { + return "pan-right"; + } else { + return "auto"; + } + } + var TouchAction = { + toString: toString$115 + }; + var Var = { + $$var, + varDefault, + toString: toString$1 + }; + var RowGap; + var ColumnGap; + var TimingFunction = { + linear: "linear", + ease: "ease", + easeIn: "easeIn", + easeOut: "easeOut", + easeInOut: "easeInOut", + stepStart: "stepStart", + stepEnd: "stepEnd", + steps, + cubicBezier, + jumpStart: "jumpStart", + jumpEnd: "jumpEnd", + jumpNone: "jumpNone", + jumpBoth: "jumpBoth", + toString: toString$24 + }; + var Transform = { + translate, + translate3d, + translateX, + translateY, + translateZ, + scale, + scale3d, + scaleX, + scaleY, + scaleZ, + rotate, + rotate3d, + rotateX, + rotateY, + rotateZ, + skew, + skewX, + skewY, + toString: toString$30 + }; + var Color = { + rgb, + rgba, + hsl, + hsla, + hex, + transparent: "transparent", + currentColor: "currentColor", + toString: toString$36 + }; + var BackdropFilter = { + toString: toString$76 + }; + var MaxWidth = None; + var MinWidth = None; + var MaxHeight = None; + var MinHeight = None; + var Gradient = { + linearGradient, + radialGradient, + repeatingLinearGradient, + repeatingRadialGradient, + conicGradient, + toString: toString$95 + }; + var FontFamilyName = { + toString: toString$105 + }; + var FontDisplay = { + toString: toString$106 + }; + exports.Cascading = Cascading; + exports.Var = Var; + exports.Time = Time; + exports.Percentage = Percentage; + exports.Url = Url; + exports.Length = Length; + exports.Angle = Angle; + exports.Direction = Direction; + exports.Position = Position; + exports.Isolation = Isolation; + exports.Resize = Resize; + exports.FontVariant = FontVariant; + exports.FontStyle = FontStyle; + exports.FlexBasis = FlexBasis; + exports.Overflow = Overflow; + exports.Margin = Margin; + exports.GridAutoFlow = GridAutoFlow; + exports.Gap = Gap; + exports.RowGap = RowGap; + exports.ColumnGap = ColumnGap; + exports.ScrollBehavior = ScrollBehavior; + exports.OverscrollBehavior = OverscrollBehavior; + exports.OverflowAnchor = OverflowAnchor; + exports.ColumnWidth = ColumnWidth; + exports.CaretColor = CaretColor; + exports.VerticalAlign = VerticalAlign; + exports.TimingFunction = TimingFunction; + exports.RepeatValue = RepeatValue; + exports.ListStyleType = ListStyleType; + exports.ListStylePosition = ListStylePosition; + exports.OutlineStyle = OutlineStyle; + exports.FontWeight = FontWeight; + exports.Transform = Transform; + exports.AnimationDirection = AnimationDirection; + exports.AnimationFillMode = AnimationFillMode; + exports.AnimationIterationCount = AnimationIterationCount; + exports.AnimationPlayState = AnimationPlayState; + exports.Cursor = Cursor; + exports.Color = Color; + exports.BorderStyle = BorderStyle; + exports.PointerEvents = PointerEvents; + exports.Perspective = Perspective; + exports.LetterSpacing = LetterSpacing; + exports.LineHeight = LineHeight; + exports.WordSpacing = WordSpacing; + exports.DisplayOutside = DisplayOutside; + exports.DisplayInside = DisplayInside; + exports.DisplayListItem = DisplayListItem; + exports.DisplayInternal = DisplayInternal; + exports.DisplayBox = DisplayBox; + exports.DisplayLegacy = DisplayLegacy; + exports.JustifySelf = JustifySelf; + exports.PositionalAlignment = PositionalAlignment; + exports.OverflowAlignment = OverflowAlignment; + exports.BaselineAlignment = BaselineAlignment; + exports.NormalAlignment = NormalAlignment; + exports.DistributedAlignment = DistributedAlignment; + exports.LegacyAlignment = LegacyAlignment; + exports.TextAlign = TextAlign; + exports.WordBreak = WordBreak; + exports.WhiteSpace = WhiteSpace; + exports.AlignItems = AlignItems; + exports.AlignSelf = AlignSelf; + exports.AlignContent = AlignContent; + exports.ObjectFit = ObjectFit; + exports.Clear = Clear; + exports.Float = Float; + exports.Visibility = Visibility; + exports.TableLayout = TableLayout; + exports.BorderCollapse = BorderCollapse; + exports.FlexWrap = FlexWrap; + exports.FlexDirection = FlexDirection; + exports.BoxSizing = BoxSizing; + exports.ColumnCount = ColumnCount; + exports.UserSelect = UserSelect; + exports.TextTransform = TextTransform; + exports.GridTemplateAreas = GridTemplateAreas; + exports.GridArea = GridArea; + exports.BackdropFilter = BackdropFilter; + exports.BackgroundAttachment = BackgroundAttachment; + exports.BackgroundClip = BackgroundClip; + exports.BackgroundOrigin = BackgroundOrigin; + exports.BackgroundPosition = BackgroundPosition; + exports.MaskPosition = MaskPosition; + exports.BackgroundRepeat = BackgroundRepeat; + exports.TextOverflow = TextOverflow; + exports.TextDecorationLine = TextDecorationLine; + exports.TextDecorationStyle = TextDecorationStyle; + exports.TextDecorationThickness = TextDecorationThickness; + exports.Width = Width; + exports.MaxWidth = MaxWidth; + exports.MinWidth = MinWidth; + exports.Height = Height; + exports.MaxHeight = MaxHeight; + exports.MinHeight = MinHeight; + exports.OverflowWrap = OverflowWrap; + exports.Gradient = Gradient; + exports.BackgroundImage = BackgroundImage; + exports.MaskImage = MaskImage; + exports.GeometryBox = GeometryBox; + exports.ClipPath = ClipPath; + exports.BackfaceVisibility = BackfaceVisibility; + exports.Flex = Flex; + exports.TransformStyle = TransformStyle; + exports.TransformBox = TransformBox; + exports.ListStyleImage = ListStyleImage; + exports.FontFamilyName = FontFamilyName; + exports.FontDisplay = FontDisplay; + exports.CounterStyleType = CounterStyleType; + exports.Counter = Counter; + exports.Counters = Counters; + exports.CounterIncrement = CounterIncrement; + exports.CounterReset = CounterReset; + exports.CounterSet = CounterSet; + exports.Content = Content; + exports.SVG = SVG; + exports.TouchAction = TouchAction; + }); + + // node_modules/bs-css/src/Css_Colors.bs.js + var require_Css_Colors_bs = __commonJS((exports) => { + "use strict"; + var Css_AtomicTypes = require_Css_AtomicTypes_bs(); + var aliceblue = Css_AtomicTypes.Color.hex("F0F8FF"); + var antiquewhite = Css_AtomicTypes.Color.hex("FAEBD7"); + var aqua = Css_AtomicTypes.Color.hex("00FFFF"); + var aquamarine = Css_AtomicTypes.Color.hex("7FFFD4"); + var azure = Css_AtomicTypes.Color.hex("F0FFFF"); + var beige = Css_AtomicTypes.Color.hex("F5F5DC"); + var bisque = Css_AtomicTypes.Color.hex("FFE4C4"); + var black = Css_AtomicTypes.Color.hex("000000"); + var blanchedalmond = Css_AtomicTypes.Color.hex("FFEBCD"); + var blue = Css_AtomicTypes.Color.hex("0000FF"); + var blueviolet = Css_AtomicTypes.Color.hex("8A2BE2"); + var brown = Css_AtomicTypes.Color.hex("A52A2A"); + var burlywood = Css_AtomicTypes.Color.hex("DEB887"); + var cadetblue = Css_AtomicTypes.Color.hex("5F9EA0"); + var chartreuse = Css_AtomicTypes.Color.hex("7FFF00"); + var chocolate = Css_AtomicTypes.Color.hex("D2691E"); + var coral = Css_AtomicTypes.Color.hex("FF7F50"); + var cornflowerblue = Css_AtomicTypes.Color.hex("6495ED"); + var cornsilk = Css_AtomicTypes.Color.hex("FFF8DC"); + var crimson = Css_AtomicTypes.Color.hex("DC143C"); + var cyan = Css_AtomicTypes.Color.hex("00FFFF"); + var darkblue = Css_AtomicTypes.Color.hex("00008B"); + var darkcyan = Css_AtomicTypes.Color.hex("008B8B"); + var darkgoldenrod = Css_AtomicTypes.Color.hex("B8860B"); + var darkgray = Css_AtomicTypes.Color.hex("A9A9A9"); + var darkgreen = Css_AtomicTypes.Color.hex("006400"); + var darkgrey = Css_AtomicTypes.Color.hex("A9A9A9"); + var darkkhaki = Css_AtomicTypes.Color.hex("BDB76B"); + var darkmagenta = Css_AtomicTypes.Color.hex("8B008B"); + var darkolivegreen = Css_AtomicTypes.Color.hex("556B2F"); + var darkorange = Css_AtomicTypes.Color.hex("FF8C00"); + var darkorchid = Css_AtomicTypes.Color.hex("9932CC"); + var darkred = Css_AtomicTypes.Color.hex("8B0000"); + var darksalmon = Css_AtomicTypes.Color.hex("E9967A"); + var darkseagreen = Css_AtomicTypes.Color.hex("8FBC8F"); + var darkslateblue = Css_AtomicTypes.Color.hex("483D8B"); + var darkslategray = Css_AtomicTypes.Color.hex("2F4F4F"); + var darkslategrey = Css_AtomicTypes.Color.hex("2F4F4F"); + var darkturquoise = Css_AtomicTypes.Color.hex("00CED1"); + var darkviolet = Css_AtomicTypes.Color.hex("9400D3"); + var deeppink = Css_AtomicTypes.Color.hex("FF1493"); + var deepskyblue = Css_AtomicTypes.Color.hex("00BFFF"); + var dimgray = Css_AtomicTypes.Color.hex("696969"); + var dimgrey = Css_AtomicTypes.Color.hex("696969"); + var dodgerblue = Css_AtomicTypes.Color.hex("1E90FF"); + var firebrick = Css_AtomicTypes.Color.hex("B22222"); + var floralwhite = Css_AtomicTypes.Color.hex("FFFAF0"); + var forestgreen = Css_AtomicTypes.Color.hex("228B22"); + var fuchsia = Css_AtomicTypes.Color.hex("FF00FF"); + var gainsboro = Css_AtomicTypes.Color.hex("DCDCDC"); + var ghostwhite = Css_AtomicTypes.Color.hex("F8F8FF"); + var gold = Css_AtomicTypes.Color.hex("FFD700"); + var goldenrod = Css_AtomicTypes.Color.hex("DAA520"); + var gray = Css_AtomicTypes.Color.hex("808080"); + var green = Css_AtomicTypes.Color.hex("008000"); + var greenyellow = Css_AtomicTypes.Color.hex("ADFF2F"); + var grey = Css_AtomicTypes.Color.hex("808080"); + var honeydew = Css_AtomicTypes.Color.hex("F0FFF0"); + var hotpink = Css_AtomicTypes.Color.hex("FF69B4"); + var indianred = Css_AtomicTypes.Color.hex("CD5C5C"); + var indigo = Css_AtomicTypes.Color.hex("4B0082"); + var ivory = Css_AtomicTypes.Color.hex("FFFFF0"); + var khaki = Css_AtomicTypes.Color.hex("F0E68C"); + var lavender = Css_AtomicTypes.Color.hex("E6E6FA"); + var lavenderblush = Css_AtomicTypes.Color.hex("FFF0F5"); + var lawngreen = Css_AtomicTypes.Color.hex("7CFC00"); + var lemonchiffon = Css_AtomicTypes.Color.hex("FFFACD"); + var lightblue = Css_AtomicTypes.Color.hex("ADD8E6"); + var lightcoral = Css_AtomicTypes.Color.hex("F08080"); + var lightcyan = Css_AtomicTypes.Color.hex("E0FFFF"); + var lightgoldenrodyellow = Css_AtomicTypes.Color.hex("FAFAD2"); + var lightgray = Css_AtomicTypes.Color.hex("D3D3D3"); + var lightgreen = Css_AtomicTypes.Color.hex("90EE90"); + var lightgrey = Css_AtomicTypes.Color.hex("D3D3D3"); + var lightpink = Css_AtomicTypes.Color.hex("FFB6C1"); + var lightsalmon = Css_AtomicTypes.Color.hex("FFA07A"); + var lightseagreen = Css_AtomicTypes.Color.hex("20B2AA"); + var lightskyblue = Css_AtomicTypes.Color.hex("87CEFA"); + var lightslategray = Css_AtomicTypes.Color.hex("778899"); + var lightslategrey = Css_AtomicTypes.Color.hex("778899"); + var lightsteelblue = Css_AtomicTypes.Color.hex("B0C4DE"); + var lightyellow = Css_AtomicTypes.Color.hex("FFFFE0"); + var lime = Css_AtomicTypes.Color.hex("00FF00"); + var limegreen = Css_AtomicTypes.Color.hex("32CD32"); + var linen = Css_AtomicTypes.Color.hex("FAF0E6"); + var magenta = Css_AtomicTypes.Color.hex("FF00FF"); + var maroon = Css_AtomicTypes.Color.hex("800000"); + var mediumaquamarine = Css_AtomicTypes.Color.hex("66CDAA"); + var mediumblue = Css_AtomicTypes.Color.hex("0000CD"); + var mediumorchid = Css_AtomicTypes.Color.hex("BA55D3"); + var mediumpurple = Css_AtomicTypes.Color.hex("9370DB"); + var mediumseagreen = Css_AtomicTypes.Color.hex("3CB371"); + var mediumslateblue = Css_AtomicTypes.Color.hex("7B68EE"); + var mediumspringgreen = Css_AtomicTypes.Color.hex("00FA9A"); + var mediumturquoise = Css_AtomicTypes.Color.hex("48D1CC"); + var mediumvioletred = Css_AtomicTypes.Color.hex("C71585"); + var midnightblue = Css_AtomicTypes.Color.hex("191970"); + var mintcream = Css_AtomicTypes.Color.hex("F5FFFA"); + var mistyrose = Css_AtomicTypes.Color.hex("FFE4E1"); + var moccasin = Css_AtomicTypes.Color.hex("FFE4B5"); + var navajowhite = Css_AtomicTypes.Color.hex("FFDEAD"); + var navy = Css_AtomicTypes.Color.hex("000080"); + var oldlace = Css_AtomicTypes.Color.hex("FDF5E6"); + var olive = Css_AtomicTypes.Color.hex("808000"); + var olivedrab = Css_AtomicTypes.Color.hex("6B8E23"); + var orange = Css_AtomicTypes.Color.hex("FFA500"); + var orangered = Css_AtomicTypes.Color.hex("FF4500"); + var orchid = Css_AtomicTypes.Color.hex("DA70D6"); + var palegoldenrod = Css_AtomicTypes.Color.hex("EEE8AA"); + var palegreen = Css_AtomicTypes.Color.hex("98FB98"); + var paleturquoise = Css_AtomicTypes.Color.hex("AFEEEE"); + var palevioletred = Css_AtomicTypes.Color.hex("DB7093"); + var papayawhip = Css_AtomicTypes.Color.hex("FFEFD5"); + var peachpuff = Css_AtomicTypes.Color.hex("FFDAB9"); + var peru = Css_AtomicTypes.Color.hex("CD853F"); + var pink = Css_AtomicTypes.Color.hex("FFC0CB"); + var plum = Css_AtomicTypes.Color.hex("DDA0DD"); + var powderblue = Css_AtomicTypes.Color.hex("B0E0E6"); + var purple = Css_AtomicTypes.Color.hex("800080"); + var rebeccapurple = Css_AtomicTypes.Color.hex("663399"); + var red = Css_AtomicTypes.Color.hex("FF0000"); + var rosybrown = Css_AtomicTypes.Color.hex("BC8F8F"); + var royalblue = Css_AtomicTypes.Color.hex("4169E1"); + var saddlebrown = Css_AtomicTypes.Color.hex("8B4513"); + var salmon = Css_AtomicTypes.Color.hex("FA8072"); + var sandybrown = Css_AtomicTypes.Color.hex("F4A460"); + var seagreen = Css_AtomicTypes.Color.hex("2E8B57"); + var seashell = Css_AtomicTypes.Color.hex("FFF5EE"); + var sienna = Css_AtomicTypes.Color.hex("A0522D"); + var silver = Css_AtomicTypes.Color.hex("C0C0C0"); + var skyblue = Css_AtomicTypes.Color.hex("87CEEB"); + var slateblue = Css_AtomicTypes.Color.hex("6A5ACD"); + var slategray = Css_AtomicTypes.Color.hex("708090"); + var slategrey = Css_AtomicTypes.Color.hex("708090"); + var snow = Css_AtomicTypes.Color.hex("FFFAFA"); + var springgreen = Css_AtomicTypes.Color.hex("00FF7F"); + var steelblue = Css_AtomicTypes.Color.hex("4682B4"); + var tan = Css_AtomicTypes.Color.hex("D2B48C"); + var teal = Css_AtomicTypes.Color.hex("008080"); + var thistle = Css_AtomicTypes.Color.hex("D8BFD8"); + var tomato = Css_AtomicTypes.Color.hex("FF6347"); + var turquoise = Css_AtomicTypes.Color.hex("40E0D0"); + var violet = Css_AtomicTypes.Color.hex("EE82EE"); + var wheat = Css_AtomicTypes.Color.hex("F5DEB3"); + var white = Css_AtomicTypes.Color.hex("FFFFFF"); + var whitesmoke = Css_AtomicTypes.Color.hex("F5F5F5"); + var yellow = Css_AtomicTypes.Color.hex("FFFF00"); + var yellowgreen = Css_AtomicTypes.Color.hex("9ACD32"); + var transparent = Css_AtomicTypes.Color.transparent; + exports.aliceblue = aliceblue; + exports.antiquewhite = antiquewhite; + exports.aqua = aqua; + exports.aquamarine = aquamarine; + exports.azure = azure; + exports.beige = beige; + exports.bisque = bisque; + exports.black = black; + exports.blanchedalmond = blanchedalmond; + exports.blue = blue; + exports.blueviolet = blueviolet; + exports.brown = brown; + exports.burlywood = burlywood; + exports.cadetblue = cadetblue; + exports.chartreuse = chartreuse; + exports.chocolate = chocolate; + exports.coral = coral; + exports.cornflowerblue = cornflowerblue; + exports.cornsilk = cornsilk; + exports.crimson = crimson; + exports.cyan = cyan; + exports.darkblue = darkblue; + exports.darkcyan = darkcyan; + exports.darkgoldenrod = darkgoldenrod; + exports.darkgray = darkgray; + exports.darkgreen = darkgreen; + exports.darkgrey = darkgrey; + exports.darkkhaki = darkkhaki; + exports.darkmagenta = darkmagenta; + exports.darkolivegreen = darkolivegreen; + exports.darkorange = darkorange; + exports.darkorchid = darkorchid; + exports.darkred = darkred; + exports.darksalmon = darksalmon; + exports.darkseagreen = darkseagreen; + exports.darkslateblue = darkslateblue; + exports.darkslategray = darkslategray; + exports.darkslategrey = darkslategrey; + exports.darkturquoise = darkturquoise; + exports.darkviolet = darkviolet; + exports.deeppink = deeppink; + exports.deepskyblue = deepskyblue; + exports.dimgray = dimgray; + exports.dimgrey = dimgrey; + exports.dodgerblue = dodgerblue; + exports.firebrick = firebrick; + exports.floralwhite = floralwhite; + exports.forestgreen = forestgreen; + exports.fuchsia = fuchsia; + exports.gainsboro = gainsboro; + exports.ghostwhite = ghostwhite; + exports.gold = gold; + exports.goldenrod = goldenrod; + exports.gray = gray; + exports.green = green; + exports.greenyellow = greenyellow; + exports.grey = grey; + exports.honeydew = honeydew; + exports.hotpink = hotpink; + exports.indianred = indianred; + exports.indigo = indigo; + exports.ivory = ivory; + exports.khaki = khaki; + exports.lavender = lavender; + exports.lavenderblush = lavenderblush; + exports.lawngreen = lawngreen; + exports.lemonchiffon = lemonchiffon; + exports.lightblue = lightblue; + exports.lightcoral = lightcoral; + exports.lightcyan = lightcyan; + exports.lightgoldenrodyellow = lightgoldenrodyellow; + exports.lightgray = lightgray; + exports.lightgreen = lightgreen; + exports.lightgrey = lightgrey; + exports.lightpink = lightpink; + exports.lightsalmon = lightsalmon; + exports.lightseagreen = lightseagreen; + exports.lightskyblue = lightskyblue; + exports.lightslategray = lightslategray; + exports.lightslategrey = lightslategrey; + exports.lightsteelblue = lightsteelblue; + exports.lightyellow = lightyellow; + exports.lime = lime; + exports.limegreen = limegreen; + exports.linen = linen; + exports.magenta = magenta; + exports.maroon = maroon; + exports.mediumaquamarine = mediumaquamarine; + exports.mediumblue = mediumblue; + exports.mediumorchid = mediumorchid; + exports.mediumpurple = mediumpurple; + exports.mediumseagreen = mediumseagreen; + exports.mediumslateblue = mediumslateblue; + exports.mediumspringgreen = mediumspringgreen; + exports.mediumturquoise = mediumturquoise; + exports.mediumvioletred = mediumvioletred; + exports.midnightblue = midnightblue; + exports.mintcream = mintcream; + exports.mistyrose = mistyrose; + exports.moccasin = moccasin; + exports.navajowhite = navajowhite; + exports.navy = navy; + exports.oldlace = oldlace; + exports.olive = olive; + exports.olivedrab = olivedrab; + exports.orange = orange; + exports.orangered = orangered; + exports.orchid = orchid; + exports.palegoldenrod = palegoldenrod; + exports.palegreen = palegreen; + exports.paleturquoise = paleturquoise; + exports.palevioletred = palevioletred; + exports.papayawhip = papayawhip; + exports.peachpuff = peachpuff; + exports.peru = peru; + exports.pink = pink; + exports.plum = plum; + exports.powderblue = powderblue; + exports.purple = purple; + exports.rebeccapurple = rebeccapurple; + exports.red = red; + exports.rosybrown = rosybrown; + exports.royalblue = royalblue; + exports.saddlebrown = saddlebrown; + exports.salmon = salmon; + exports.sandybrown = sandybrown; + exports.seagreen = seagreen; + exports.seashell = seashell; + exports.sienna = sienna; + exports.silver = silver; + exports.skyblue = skyblue; + exports.slateblue = slateblue; + exports.slategray = slategray; + exports.slategrey = slategrey; + exports.snow = snow; + exports.springgreen = springgreen; + exports.steelblue = steelblue; + exports.tan = tan; + exports.teal = teal; + exports.thistle = thistle; + exports.tomato = tomato; + exports.turquoise = turquoise; + exports.violet = violet; + exports.wheat = wheat; + exports.white = white; + exports.whitesmoke = whitesmoke; + exports.yellow = yellow; + exports.yellowgreen = yellowgreen; + exports.transparent = transparent; + }); + + // node_modules/rescript/lib/js/js_option.js + var require_js_option = __commonJS((exports) => { + "use strict"; + var Caml_option = require_caml_option(); + function some(x) { + return Caml_option.some(x); + } + function isSome(param) { + return param !== void 0; + } + function isSomeValue(eq, v, x) { + if (x !== void 0) { + return eq(v, Caml_option.valFromOption(x)); + } else { + return false; + } + } + function isNone(param) { + return param === void 0; + } + function getExn(x) { + if (x !== void 0) { + return Caml_option.valFromOption(x); + } + throw new Error("getExn"); + } + function equal(eq, a, b) { + if (a !== void 0) { + if (b !== void 0) { + return eq(Caml_option.valFromOption(a), Caml_option.valFromOption(b)); + } else { + return false; + } + } else { + return b === void 0; + } + } + function andThen(f, x) { + if (x !== void 0) { + return f(Caml_option.valFromOption(x)); + } + } + function map(f, x) { + if (x !== void 0) { + return Caml_option.some(f(Caml_option.valFromOption(x))); + } + } + function getWithDefault(a, x) { + if (x !== void 0) { + return Caml_option.valFromOption(x); + } else { + return a; + } + } + function filter(f, x) { + if (x === void 0) { + return; + } + var x$1 = Caml_option.valFromOption(x); + if (f(x$1)) { + return Caml_option.some(x$1); + } + } + function firstSome(a, b) { + if (a !== void 0) { + return a; + } else if (b !== void 0) { + return b; + } else { + return; + } + } + var $$default = getWithDefault; + exports.some = some; + exports.isSome = isSome; + exports.isSomeValue = isSomeValue; + exports.isNone = isNone; + exports.getExn = getExn; + exports.equal = equal; + exports.andThen = andThen; + exports.map = map; + exports.getWithDefault = getWithDefault; + exports.$$default = $$default; + exports.default = $$default; + exports.__esModule = true; + exports.filter = filter; + exports.firstSome = firstSome; + }); + + // node_modules/rescript/lib/js/belt_Option.js + var require_belt_Option = __commonJS((exports) => { + "use strict"; + var Curry = require_curry(); + var Caml_option = require_caml_option(); + function keepU(opt, p) { + if (opt !== void 0 && p(Caml_option.valFromOption(opt))) { + return opt; + } + } + function keep(opt, p) { + return keepU(opt, Curry.__1(p)); + } + function forEachU(opt, f) { + if (opt !== void 0) { + return f(Caml_option.valFromOption(opt)); + } + } + function forEach(opt, f) { + forEachU(opt, Curry.__1(f)); + } + function getExn(x) { + if (x !== void 0) { + return Caml_option.valFromOption(x); + } + throw { + RE_EXN_ID: "Not_found", + Error: new Error() + }; + } + function mapWithDefaultU(opt, $$default, f) { + if (opt !== void 0) { + return f(Caml_option.valFromOption(opt)); + } else { + return $$default; + } + } + function mapWithDefault(opt, $$default, f) { + return mapWithDefaultU(opt, $$default, Curry.__1(f)); + } + function mapU(opt, f) { + if (opt !== void 0) { + return Caml_option.some(f(Caml_option.valFromOption(opt))); + } + } + function map(opt, f) { + return mapU(opt, Curry.__1(f)); + } + function flatMapU(opt, f) { + if (opt !== void 0) { + return f(Caml_option.valFromOption(opt)); + } + } + function flatMap(opt, f) { + return flatMapU(opt, Curry.__1(f)); + } + function getWithDefault(opt, $$default) { + if (opt !== void 0) { + return Caml_option.valFromOption(opt); + } else { + return $$default; + } + } + function orElse(opt, other) { + if (opt !== void 0) { + return opt; + } else { + return other; + } + } + function isSome(param) { + return param !== void 0; + } + function isNone(x) { + return x === void 0; + } + function eqU(a, b, f) { + if (a !== void 0) { + if (b !== void 0) { + return f(Caml_option.valFromOption(a), Caml_option.valFromOption(b)); + } else { + return false; + } + } else { + return b === void 0; + } + } + function eq(a, b, f) { + return eqU(a, b, Curry.__2(f)); + } + function cmpU(a, b, f) { + if (a !== void 0) { + if (b !== void 0) { + return f(Caml_option.valFromOption(a), Caml_option.valFromOption(b)); + } else { + return 1; + } + } else if (b !== void 0) { + return -1; + } else { + return 0; + } + } + function cmp(a, b, f) { + return cmpU(a, b, Curry.__2(f)); + } + exports.keepU = keepU; + exports.keep = keep; + exports.forEachU = forEachU; + exports.forEach = forEach; + exports.getExn = getExn; + exports.mapWithDefaultU = mapWithDefaultU; + exports.mapWithDefault = mapWithDefault; + exports.mapU = mapU; + exports.map = map; + exports.flatMapU = flatMapU; + exports.flatMap = flatMap; + exports.getWithDefault = getWithDefault; + exports.orElse = orElse; + exports.isSome = isSome; + exports.isNone = isNone; + exports.eqU = eqU; + exports.eq = eq; + exports.cmpU = cmpU; + exports.cmp = cmp; + }); + + // node_modules/bs-css/src/Css_Js_Core.bs.js + var require_Css_Js_Core_bs = __commonJS((exports) => { + "use strict"; + var Curry = require_curry(); + var Js_option = require_js_option(); + var Belt_Array = require_belt_Array(); + var Belt_Option = require_belt_Option(); + var Css_AtomicTypes = require_Css_AtomicTypes_bs(); + function ruleToDict(dict, rule) { + switch (rule.TAG | 0) { + case 0: + var value = rule._1; + var name = rule._0; + if (name === "content") { + dict[name] = value === "" ? '""' : value; + } else { + dict[name] = value; + } + break; + case 1: + dict[rule._0] = toJson(rule._1); + break; + case 2: + dict[":" + rule._0] = toJson(rule._1); + break; + case 3: + dict[":" + (rule._0 + ("(" + (rule._1 + ")")))] = toJson(rule._2); + break; + } + return dict; + } + function toJson(rules) { + return Belt_Array.reduceU(rules, {}, ruleToDict); + } + function Make(CssImpl) { + var insertRule = function(css) { + CssImpl.injectRaw(css); + }; + var renderRule = function(renderer, css) { + CssImpl.renderRaw(renderer, css); + }; + var $$global = function(selector2, rules) { + CssImpl.injectRules(selector2, toJson(rules)); + }; + var renderGlobal = function(renderer, selector2, rules) { + CssImpl.renderRules(renderer, selector2, toJson(rules)); + }; + var style = function(rules) { + return CssImpl.make(toJson(rules)); + }; + var merge = function(styles) { + return CssImpl.mergeStyles(styles); + }; + var merge2 = function(s, s2) { + return merge([ + s, + s2 + ]); + }; + var merge3 = function(s, s2, s3) { + return merge([ + s, + s2, + s3 + ]); + }; + var merge4 = function(s, s2, s3, s4) { + return merge([ + s, + s2, + s3, + s4 + ]); + }; + var framesToDict = function(frames) { + return Belt_Array.reduceU(frames, {}, function(dict, param) { + dict[param[0].toString() + "%"] = toJson(param[1]); + return dict; + }); + }; + var keyframes = function(frames) { + return CssImpl.makeKeyframes(framesToDict(frames)); + }; + var renderKeyframes = function(renderer, frames) { + return CssImpl.renderKeyframes(renderer, framesToDict(frames)); + }; + return { + insertRule, + renderRule, + $$global, + renderGlobal, + style, + merge, + merge2, + merge3, + merge4, + keyframes, + renderKeyframes + }; + } + function join(strings, separator) { + return Belt_Array.reduceWithIndexU(strings, "", function(acc, item, index) { + if (index === 0) { + return item; + } else { + return acc + (separator + item); + } + }); + } + function string_of_content(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return Css_AtomicTypes.Content.toString(x); + } + } + var variant = x.NAME; + if (variant === "linearGradient" || variant === "radialGradient" || variant === "repeatingLinearGradient" || variant === "repeatingRadialGradient" || variant === "conicGradient") { + return Css_AtomicTypes.Gradient.toString(x); + } else if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else if (variant === "url") { + return Css_AtomicTypes.Url.toString(x); + } else if (variant === "counters") { + return Css_AtomicTypes.Counters.toString(x); + } else if (variant === "counter") { + return Css_AtomicTypes.Counter.toString(x); + } else { + return Css_AtomicTypes.Content.toString(x); + } + } + function string_of_counter_increment(x) { + if (typeof x === "object") { + if (x.NAME === "increment") { + return Css_AtomicTypes.CounterIncrement.toString(x); + } else { + return Css_AtomicTypes.Var.toString(x); + } + } else if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return Css_AtomicTypes.CounterIncrement.toString(x); + } + } + function string_of_counter_reset(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return Css_AtomicTypes.CounterReset.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else { + return Css_AtomicTypes.CounterReset.toString(x); + } + } + function string_of_counter_set(x) { + if (typeof x === "object") { + if (x.NAME === "set") { + return Css_AtomicTypes.CounterSet.toString(x); + } else { + return Css_AtomicTypes.Var.toString(x); + } + } else if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return Css_AtomicTypes.CounterSet.toString(x); + } + } + function string_of_column_gap(x) { + if (typeof x !== "object") { + if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else if (x === "normal") { + return Css_AtomicTypes.Gap.toString(x); + } else { + return Css_AtomicTypes.Cascading.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else if (variant === "percent") { + return Css_AtomicTypes.Percentage.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function string_of_row_gap(x) { + if (typeof x !== "object") { + if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else if (x === "normal") { + return Css_AtomicTypes.Gap.toString(x); + } else { + return Css_AtomicTypes.Cascading.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else if (variant === "percent") { + return Css_AtomicTypes.Percentage.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function string_of_gap(x) { + if (typeof x !== "object") { + if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else if (x === "normal") { + return Css_AtomicTypes.Gap.toString(x); + } else { + return Css_AtomicTypes.Cascading.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else if (variant === "percent") { + return Css_AtomicTypes.Percentage.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function string_of_position(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else { + return "auto"; + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function string_of_color(x) { + if (typeof x !== "object") { + return Css_AtomicTypes.Color.toString(x); + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else { + return Css_AtomicTypes.Color.toString(x); + } + } + function string_of_dasharray(x) { + if (typeof x === "object" && x.NAME === "percent") { + return Css_AtomicTypes.Percentage.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function important(v) { + if (v.TAG === 0) { + return { + TAG: 0, + _0: v._0, + _1: v._1 + " !important" + }; + } else { + return v; + } + } + function label(label$1) { + return { + TAG: 0, + _0: "label", + _1: label$1 + }; + } + function alignContent(x) { + return { + TAG: 0, + _0: "alignContent", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "spaceBetween" || x === "stretch" || x === "spaceAround" || x === "spaceEvenly" ? Css_AtomicTypes.DistributedAlignment.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "baseline" || x === "firstBaseline" || x === "lastBaseline" ? Css_AtomicTypes.BaselineAlignment.toString(x) : x === "normal" ? Css_AtomicTypes.NormalAlignment.toString(x) : Css_AtomicTypes.AlignContent.toString(x) + }; + } + function alignItems(x) { + return { + TAG: 0, + _0: "alignItems", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "baseline" || x === "firstBaseline" || x === "lastBaseline" ? Css_AtomicTypes.BaselineAlignment.toString(x) : x === "normal" || x === "stretch" ? Css_AtomicTypes.AlignItems.toString(x) : Css_AtomicTypes.PositionalAlignment.toString(x) + }; + } + function alignSelf(x) { + return { + TAG: 0, + _0: "alignSelf", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "selfStart" || x === "flexEnd" || x === "flexStart" || x === "center" || x === "start" || x === "selfEnd" || x === "right" || x === "left" || x === "end_" ? Css_AtomicTypes.PositionalAlignment.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "baseline" || x === "firstBaseline" || x === "lastBaseline" ? Css_AtomicTypes.BaselineAlignment.toString(x) : Css_AtomicTypes.AlignSelf.toString(x) + }; + } + function animationDelay(x) { + return { + TAG: 0, + _0: "animationDelay", + _1: x.toString() + "ms" + }; + } + function animationDirection(x) { + return { + TAG: 0, + _0: "animationDirection", + _1: Css_AtomicTypes.AnimationDirection.toString(x) + }; + } + function animationDuration(x) { + return { + TAG: 0, + _0: "animationDuration", + _1: x.toString() + "ms" + }; + } + function animationFillMode(x) { + return { + TAG: 0, + _0: "animationFillMode", + _1: Css_AtomicTypes.AnimationFillMode.toString(x) + }; + } + function animationIterationCount(x) { + return { + TAG: 0, + _0: "animationIterationCount", + _1: Css_AtomicTypes.AnimationIterationCount.toString(x) + }; + } + function animationPlayState(x) { + return { + TAG: 0, + _0: "animationPlayState", + _1: Css_AtomicTypes.AnimationPlayState.toString(x) + }; + } + function animationTimingFunction(x) { + return { + TAG: 0, + _0: "animationTimingFunction", + _1: Css_AtomicTypes.TimingFunction.toString(x) + }; + } + function backfaceVisibility(x) { + return { + TAG: 0, + _0: "backfaceVisibility", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "visible" || x === "hidden" ? Css_AtomicTypes.BackfaceVisibility.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function backdropFilter(x) { + return { + TAG: 0, + _0: "backdropFilter", + _1: join(Belt_Array.map(x, Css_AtomicTypes.BackdropFilter.toString), ", ") + }; + } + function backgroundAttachment(x) { + return { + TAG: 0, + _0: "backgroundAttachment", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.BackgroundAttachment.toString(x) + }; + } + function backgroundColor(x) { + return { + TAG: 0, + _0: "backgroundColor", + _1: string_of_color(x) + }; + } + function backgroundClip(x) { + return { + TAG: 0, + _0: "backgroundClip", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.BackgroundClip.toString(x) + }; + } + function backgroundImage(x) { + return { + TAG: 0, + _0: "backgroundImage", + _1: typeof x === "object" ? x.NAME === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Gradient.toString(x) : Css_AtomicTypes.BackgroundImage.toString(x) + }; + } + function maskImage(x) { + return { + TAG: 0, + _0: "maskImage", + _1: typeof x === "object" ? x.NAME === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Gradient.toString(x) : Css_AtomicTypes.MaskImage.toString(x) + }; + } + function backgroundOrigin(x) { + return { + TAG: 0, + _0: "backgroundOrigin", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.BackgroundOrigin.toString(x) + }; + } + function string_of_backgroundposition(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else { + return Css_AtomicTypes.BackgroundPosition.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } + if (variant !== "hv") { + return Css_AtomicTypes.Length.toString(x); + } + var match = x.VAL; + var v = match[1]; + var h = match[0]; + return (typeof h === "object" || h === "zero" ? Css_AtomicTypes.Length.toString(h) : Curry._1(Css_AtomicTypes.BackgroundPosition.X.toString, h)) + (" " + (typeof v === "object" || !(v === "center" || v === "top" || v === "bottom") ? Css_AtomicTypes.Length.toString(v) : Curry._1(Css_AtomicTypes.BackgroundPosition.Y.toString, v))); + } + function backgroundPosition(x) { + return { + TAG: 0, + _0: "backgroundPosition", + _1: string_of_backgroundposition(x) + }; + } + function backgroundPositions(bp) { + return { + TAG: 0, + _0: "backgroundPosition", + _1: join(Belt_Array.map(bp, string_of_backgroundposition), ", ") + }; + } + function backgroundPosition4(x, offsetX, y, offsetY) { + return { + TAG: 0, + _0: "backgroundPosition", + _1: Curry._1(Css_AtomicTypes.BackgroundPosition.X.toString, x) + (" " + (Css_AtomicTypes.Length.toString(offsetX) + (" " + (Curry._1(Css_AtomicTypes.BackgroundPosition.Y.toString, y) + (" " + Css_AtomicTypes.Length.toString(offsetY)))))) + }; + } + function backgroundRepeat(x) { + var tmp; + if (typeof x === "object") { + if (x.NAME === "hv") { + var match = x.VAL; + tmp = Css_AtomicTypes.BackgroundRepeat.toString(match[0]) + (" " + Css_AtomicTypes.BackgroundRepeat.toString(match[1])); + } else { + tmp = Css_AtomicTypes.Var.toString(x); + } + } else { + tmp = x === "repeatY" || x === "repeatX" || x === "repeat" || x === "space" || x === "round" || x === "noRepeat" ? Css_AtomicTypes.BackgroundRepeat.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "backgroundRepeat", + _1: tmp + }; + } + function string_of_maskposition(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else { + return Css_AtomicTypes.MaskPosition.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } + if (variant !== "hv") { + return Css_AtomicTypes.Length.toString(x); + } + var match = x.VAL; + var v = match[1]; + var h = match[0]; + return (typeof h === "object" || h === "zero" ? Css_AtomicTypes.Length.toString(h) : Curry._1(Css_AtomicTypes.MaskPosition.X.toString, h)) + (" " + (typeof v === "object" || !(v === "center" || v === "top" || v === "bottom") ? Css_AtomicTypes.Length.toString(v) : Curry._1(Css_AtomicTypes.MaskPosition.Y.toString, v))); + } + function maskPosition(x) { + return { + TAG: 0, + _0: "maskPosition", + _1: string_of_maskposition(x) + }; + } + function maskPositions(mp) { + return { + TAG: 0, + _0: "maskPosition", + _1: join(Belt_Array.map(mp, string_of_maskposition), ", ") + }; + } + function borderBottomColor(x) { + return { + TAG: 0, + _0: "borderBottomColor", + _1: string_of_color(x) + }; + } + function borderBottomLeftRadius(x) { + return { + TAG: 0, + _0: "borderBottomLeftRadius", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderBottomRightRadius(x) { + return { + TAG: 0, + _0: "borderBottomRightRadius", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderBottomWidth(x) { + return { + TAG: 0, + _0: "borderBottomWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderCollapse(x) { + return { + TAG: 0, + _0: "borderCollapse", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.BorderCollapse.toString(x) + }; + } + function borderColor(x) { + return { + TAG: 0, + _0: "borderColor", + _1: string_of_color(x) + }; + } + function borderLeftColor(x) { + return { + TAG: 0, + _0: "borderLeftColor", + _1: string_of_color(x) + }; + } + function borderLeftWidth(x) { + return { + TAG: 0, + _0: "borderLeftWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderSpacing(x) { + return { + TAG: 0, + _0: "borderSpacing", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderRadius(x) { + return { + TAG: 0, + _0: "borderRadius", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderRadius4(topLeft, topRight, bottomLeft, bottomRight) { + return { + TAG: 0, + _0: "borderRadius", + _1: Css_AtomicTypes.Length.toString(topLeft) + (" " + (Css_AtomicTypes.Length.toString(topRight) + (" " + (Css_AtomicTypes.Length.toString(bottomLeft) + (" " + Css_AtomicTypes.Length.toString(bottomRight)))))) + }; + } + function borderRightColor(x) { + return { + TAG: 0, + _0: "borderRightColor", + _1: string_of_color(x) + }; + } + function borderRightWidth(x) { + return { + TAG: 0, + _0: "borderRightWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderTopColor(x) { + return { + TAG: 0, + _0: "borderTopColor", + _1: string_of_color(x) + }; + } + function borderTopLeftRadius(x) { + return { + TAG: 0, + _0: "borderTopLeftRadius", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderTopRightRadius(x) { + return { + TAG: 0, + _0: "borderTopRightRadius", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderTopWidth(x) { + return { + TAG: 0, + _0: "borderTopWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function borderWidth(x) { + return { + TAG: 0, + _0: "borderWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function bottom(x) { + return { + TAG: 0, + _0: "bottom", + _1: string_of_position(x) + }; + } + function boxSizing(x) { + return { + TAG: 0, + _0: "boxSizing", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.BoxSizing.toString(x) + }; + } + function clear(x) { + return { + TAG: 0, + _0: "clear", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Clear.toString(x) + }; + } + function clipPath(x) { + return { + TAG: 0, + _0: "clipPath", + _1: typeof x === "object" ? x.NAME === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Var.toString(x) : x === "none" ? Css_AtomicTypes.ClipPath.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.GeometryBox.toString(x) + }; + } + function color(x) { + return { + TAG: 0, + _0: "color", + _1: string_of_color(x) + }; + } + function columnCount(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.ColumnCount.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.ColumnCount.toString(x); + } + return { + TAG: 0, + _0: "columnCount", + _1: tmp + }; + } + function columnGap(x) { + return { + TAG: 0, + _0: "columnGap", + _1: string_of_column_gap(x) + }; + } + function contentRule(x) { + return { + TAG: 0, + _0: "content", + _1: string_of_content(x) + }; + } + function contentRules(xs) { + return { + TAG: 0, + _0: "content", + _1: join(Belt_Array.map(xs, string_of_content), " ") + }; + } + function counterIncrement(x) { + return { + TAG: 0, + _0: "counterIncrement", + _1: string_of_counter_increment(x) + }; + } + function countersIncrement(xs) { + return { + TAG: 0, + _0: "counterIncrement", + _1: join(Belt_Array.map(xs, string_of_counter_increment), " ") + }; + } + function counterReset(x) { + return { + TAG: 0, + _0: "counterReset", + _1: string_of_counter_reset(x) + }; + } + function countersReset(xs) { + return { + TAG: 0, + _0: "counterReset", + _1: join(Belt_Array.map(xs, string_of_counter_reset), " ") + }; + } + function counterSet(x) { + return { + TAG: 0, + _0: "counterSet", + _1: string_of_counter_set(x) + }; + } + function countersSet(xs) { + return { + TAG: 0, + _0: "counterSet", + _1: join(Belt_Array.map(xs, string_of_counter_set), " ") + }; + } + function cursor(x) { + return { + TAG: 0, + _0: "cursor", + _1: Css_AtomicTypes.Cursor.toString(x) + }; + } + function direction(x) { + return { + TAG: 0, + _0: "direction", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "rtl" || x === "ltr" ? Css_AtomicTypes.Direction.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function display(x) { + return { + TAG: 0, + _0: "display", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "table" || x === "grid" || x === "flex" ? Css_AtomicTypes.DisplayInside.toString(x) : x === "contents" || x === "none" ? Css_AtomicTypes.DisplayBox.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "inlineGrid" || x === "inlineFlex" || x === "inlineBlock" || x === "inlineTable" ? Css_AtomicTypes.DisplayLegacy.toString(x) : x === "block" || x === "inline" || x === "runIn" ? Css_AtomicTypes.DisplayOutside.toString(x) : x === "listItem" ? Css_AtomicTypes.DisplayListItem.toString(x) : Css_AtomicTypes.DisplayInternal.toString(x) + }; + } + function flex(x) { + return { + TAG: 0, + _0: "flex", + _1: typeof x === "object" ? x.VAL.toString() : Css_AtomicTypes.Flex.toString(x) + }; + } + function flexDirection(x) { + return { + TAG: 0, + _0: "flexDirection", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.FlexDirection.toString(x) + }; + } + function flexGrow(x) { + return { + TAG: 0, + _0: "flexGrow", + _1: x.toString() + }; + } + function flexShrink(x) { + return { + TAG: 0, + _0: "flexShrink", + _1: x.toString() + }; + } + function flexWrap(x) { + return { + TAG: 0, + _0: "flexWrap", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "nowrap" || x === "wrapReverse" || x === "wrap" ? Css_AtomicTypes.FlexWrap.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function $$float(x) { + return { + TAG: 0, + _0: "float", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Float.toString(x) + }; + } + function fontFamily(x) { + return { + TAG: 0, + _0: "fontFamily", + _1: typeof x === "object" ? x.NAME === "custom" ? Css_AtomicTypes.FontFamilyName.toString(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.FontFamilyName.toString(x) + }; + } + function fontFamilies(xs) { + return { + TAG: 0, + _0: "fontFamily", + _1: join(Belt_Array.map(xs, Css_AtomicTypes.FontFamilyName.toString), ", ") + }; + } + function fontSize(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "fontSize", + _1: tmp + }; + } + function fontStyle(x) { + return { + TAG: 0, + _0: "fontStyle", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "normal" || x === "oblique" || x === "italic" ? Css_AtomicTypes.FontStyle.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function fontVariant(x) { + return { + TAG: 0, + _0: "fontVariant", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "normal" || x === "smallCaps" ? Css_AtomicTypes.FontVariant.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function fontWeight(x) { + return { + TAG: 0, + _0: "fontWeight", + _1: typeof x === "object" ? x.NAME === "num" ? Css_AtomicTypes.FontWeight.toString(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.FontWeight.toString(x) + }; + } + function gridAutoFlow(x) { + return { + TAG: 0, + _0: "gridAutoFlow", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.GridAutoFlow.toString(x) + }; + } + function gridColumn(start, end$p) { + return { + TAG: 0, + _0: "gridColumn", + _1: start.toString() + (" / " + end$p.toString()) + }; + } + function gridColumnGap(x) { + return { + TAG: 0, + _0: "gridColumnGap", + _1: string_of_column_gap(x) + }; + } + function gridColumnStart(n) { + return { + TAG: 0, + _0: "gridColumnStart", + _1: n.toString() + }; + } + function gridColumnEnd(n) { + return { + TAG: 0, + _0: "gridColumnEnd", + _1: n.toString() + }; + } + function gridRow(start, end$p) { + return { + TAG: 0, + _0: "gridRow", + _1: start.toString() + (" / " + end$p.toString()) + }; + } + function gap(x) { + return { + TAG: 0, + _0: "gap", + _1: string_of_gap(x) + }; + } + function gridGap(x) { + return { + TAG: 0, + _0: "gridGap", + _1: string_of_gap(x) + }; + } + function gap2(rowGap2, columnGap2) { + return { + TAG: 0, + _0: "gap", + _1: string_of_gap(rowGap2) + (" " + string_of_gap(columnGap2)) + }; + } + function rowGap(x) { + return { + TAG: 0, + _0: "rowGap", + _1: string_of_row_gap(x) + }; + } + function gridRowGap(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "gridRowGap", + _1: tmp + }; + } + function gridRowEnd(n) { + return { + TAG: 0, + _0: "gridRowEnd", + _1: n.toString() + }; + } + function gridRowStart(n) { + return { + TAG: 0, + _0: "gridRowStart", + _1: n.toString() + }; + } + function height(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Height.toString(x); + } + return { + TAG: 0, + _0: "height", + _1: tmp + }; + } + function justifyContent(x) { + return { + TAG: 0, + _0: "justifyContent", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "spaceBetween" || x === "stretch" || x === "spaceAround" || x === "spaceEvenly" ? Css_AtomicTypes.DistributedAlignment.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "normal" ? Css_AtomicTypes.NormalAlignment.toString(x) : Css_AtomicTypes.PositionalAlignment.toString(x) + }; + } + function justifyItems(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.OverflowAlignment.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "legacyRight" || x === "legacy" || x === "legacyLeft" || x === "legacyCenter" ? Css_AtomicTypes.LegacyAlignment.toString(x) : x === "baseline" || x === "firstBaseline" || x === "lastBaseline" ? Css_AtomicTypes.BaselineAlignment.toString(x) : x === "normal" ? Css_AtomicTypes.NormalAlignment.toString(x) : Css_AtomicTypes.PositionalAlignment.toString(x); + } + return { + TAG: 0, + _0: "justifyItems", + _1: tmp + }; + } + function left(x) { + return { + TAG: 0, + _0: "left", + _1: string_of_position(x) + }; + } + function letterSpacing(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : x === "normal" ? Css_AtomicTypes.LetterSpacing.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "letterSpacing", + _1: tmp + }; + } + function lineHeight(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "abs" ? Css_AtomicTypes.LineHeight.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : x === "normal" ? Css_AtomicTypes.LineHeight.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "lineHeight", + _1: tmp + }; + } + function listStyle(style, position2, image) { + return { + TAG: 0, + _0: "listStyle", + _1: Css_AtomicTypes.ListStyleType.toString(style) + (" " + (Css_AtomicTypes.ListStylePosition.toString(position2) + (" " + (typeof image === "object" ? Css_AtomicTypes.Url.toString(image) : Css_AtomicTypes.ListStyleImage.toString(image))))) + }; + } + function listStyleImage(x) { + return { + TAG: 0, + _0: "listStyleImage", + _1: typeof x === "object" ? x.NAME === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.ListStyleImage.toString(x) + }; + } + function listStyleType(x) { + return { + TAG: 0, + _0: "listStyleType", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.ListStyleType.toString(x) + }; + } + function listStylePosition(x) { + return { + TAG: 0, + _0: "listStylePosition", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "inside" || x === "outside" ? Css_AtomicTypes.ListStylePosition.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function marginToString(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else if (x === "zero") { + return Css_AtomicTypes.Length.toString(x); + } else { + return Css_AtomicTypes.Margin.toString(x); + } + } + var variant = x.NAME; + if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else { + return Css_AtomicTypes.Length.toString(x); + } + } + function margin(x) { + return { + TAG: 0, + _0: "margin", + _1: marginToString(x) + }; + } + function margin2(v, h) { + return { + TAG: 0, + _0: "margin", + _1: marginToString(v) + (" " + marginToString(h)) + }; + } + function margin3(top2, h, bottom2) { + return { + TAG: 0, + _0: "margin", + _1: marginToString(top2) + (" " + (marginToString(h) + (" " + marginToString(bottom2)))) + }; + } + function margin4(top2, right2, bottom2, left2) { + return { + TAG: 0, + _0: "margin", + _1: marginToString(top2) + (" " + (marginToString(right2) + (" " + (marginToString(bottom2) + (" " + marginToString(left2)))))) + }; + } + function marginLeft(x) { + return { + TAG: 0, + _0: "marginLeft", + _1: marginToString(x) + }; + } + function marginRight(x) { + return { + TAG: 0, + _0: "marginRight", + _1: marginToString(x) + }; + } + function marginTop(x) { + return { + TAG: 0, + _0: "marginTop", + _1: marginToString(x) + }; + } + function marginBottom(x) { + return { + TAG: 0, + _0: "marginBottom", + _1: marginToString(x) + }; + } + function maxHeight(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "none" ? Css_AtomicTypes.MaxHeight.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Height.toString(x); + } + return { + TAG: 0, + _0: "maxHeight", + _1: tmp + }; + } + function maxWidth(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "none" ? Css_AtomicTypes.MaxWidth.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Width.toString(x); + } + return { + TAG: 0, + _0: "maxWidth", + _1: tmp + }; + } + function minHeight(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "none" ? Css_AtomicTypes.MinHeight.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Height.toString(x); + } + return { + TAG: 0, + _0: "minHeight", + _1: tmp + }; + } + function minWidth(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "none" ? Css_AtomicTypes.MinWidth.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Width.toString(x); + } + return { + TAG: 0, + _0: "minWidth", + _1: tmp + }; + } + function objectFit(x) { + return { + TAG: 0, + _0: "objectFit", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.ObjectFit.toString(x) + }; + } + function objectPosition(x) { + return { + TAG: 0, + _0: "objectPosition", + _1: string_of_backgroundposition(x) + }; + } + function opacity(x) { + return { + TAG: 0, + _0: "opacity", + _1: x.toString() + }; + } + function outline(size2, style, color2) { + return { + TAG: 0, + _0: "outline", + _1: Css_AtomicTypes.Length.toString(size2) + (" " + (Css_AtomicTypes.OutlineStyle.toString(style) + (" " + string_of_color(color2)))) + }; + } + function outlineColor(x) { + return { + TAG: 0, + _0: "outlineColor", + _1: string_of_color(x) + }; + } + function outlineOffset(x) { + return { + TAG: 0, + _0: "outlineOffset", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function outlineStyle(x) { + return { + TAG: 0, + _0: "outlineStyle", + _1: Css_AtomicTypes.OutlineStyle.toString(x) + }; + } + function outlineWidth(x) { + return { + TAG: 0, + _0: "outlineWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function overflow(x) { + return { + TAG: 0, + _0: "overflow", + _1: Css_AtomicTypes.Overflow.toString(x) + }; + } + function overflowX(x) { + return { + TAG: 0, + _0: "overflowX", + _1: Css_AtomicTypes.Overflow.toString(x) + }; + } + function overflowY(x) { + return { + TAG: 0, + _0: "overflowY", + _1: Css_AtomicTypes.Overflow.toString(x) + }; + } + function overflowWrap(x) { + return { + TAG: 0, + _0: "overflowWrap", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "breakWord" || x === "anywhere" || x === "normal" ? Css_AtomicTypes.OverflowWrap.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function padding(x) { + return { + TAG: 0, + _0: "padding", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function padding2(v, h) { + return { + TAG: 0, + _0: "padding", + _1: Css_AtomicTypes.Length.toString(v) + (" " + Css_AtomicTypes.Length.toString(h)) + }; + } + function padding3(top2, h, bottom2) { + return { + TAG: 0, + _0: "padding", + _1: Css_AtomicTypes.Length.toString(top2) + (" " + (Css_AtomicTypes.Length.toString(h) + (" " + Css_AtomicTypes.Length.toString(bottom2)))) + }; + } + function padding4(top2, right2, bottom2, left2) { + return { + TAG: 0, + _0: "padding", + _1: Css_AtomicTypes.Length.toString(top2) + (" " + (Css_AtomicTypes.Length.toString(right2) + (" " + (Css_AtomicTypes.Length.toString(bottom2) + (" " + Css_AtomicTypes.Length.toString(left2)))))) + }; + } + function paddingBottom(x) { + return { + TAG: 0, + _0: "paddingBottom", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function paddingLeft(x) { + return { + TAG: 0, + _0: "paddingLeft", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function paddingRight(x) { + return { + TAG: 0, + _0: "paddingRight", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function paddingTop(x) { + return { + TAG: 0, + _0: "paddingTop", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function perspective(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Perspective.toString(x); + } + return { + TAG: 0, + _0: "perspective", + _1: tmp + }; + } + function perspectiveOrigin(x, y) { + return { + TAG: 0, + _0: "perspectiveOrigin", + _1: (typeof x === "object" || x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Perspective.toString(x)) + (" " + (typeof y === "object" || y === "zero" ? Css_AtomicTypes.Length.toString(y) : Css_AtomicTypes.Perspective.toString(y))) + }; + } + function pointerEvents(x) { + return { + TAG: 0, + _0: "pointerEvents", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.PointerEvents.toString(x) + }; + } + function position(x) { + return { + TAG: 0, + _0: "position", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Position.toString(x) + }; + } + function isolation(x) { + return { + TAG: 0, + _0: "isolation", + _1: x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Isolation.toString(x) + }; + } + function justifySelf(x) { + return { + TAG: 0, + _0: "justifySelf", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "selfStart" || x === "flexEnd" || x === "flexStart" || x === "center" || x === "start" || x === "selfEnd" || x === "right" || x === "left" || x === "end_" ? Css_AtomicTypes.PositionalAlignment.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "baseline" || x === "firstBaseline" || x === "lastBaseline" ? Css_AtomicTypes.BaselineAlignment.toString(x) : Css_AtomicTypes.JustifySelf.toString(x) + }; + } + function resize(x) { + return { + TAG: 0, + _0: "resize", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Resize.toString(x) + }; + } + function right(x) { + return { + TAG: 0, + _0: "right", + _1: string_of_position(x) + }; + } + function tableLayout(x) { + return { + TAG: 0, + _0: "tableLayout", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TableLayout.toString(x) + }; + } + function textAlign(x) { + return { + TAG: 0, + _0: "textAlign", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TextAlign.toString(x) + }; + } + function textDecorationColor(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Color.toString(x); + } else { + tmp = x === "transparent" || x === "currentColor" ? Css_AtomicTypes.Color.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "textDecorationColor", + _1: tmp + }; + } + function textDecorationLine(x) { + return { + TAG: 0, + _0: "textDecorationLine", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TextDecorationLine.toString(x) + }; + } + function textDecorationStyle(x) { + return { + TAG: 0, + _0: "textDecorationStyle", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "double" || x === "dotted" || x === "dashed" || x === "solid" || x === "wavy" ? Css_AtomicTypes.TextDecorationStyle.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function textIndent(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "textIndent", + _1: tmp + }; + } + function textOverflow(x) { + return { + TAG: 0, + _0: "textOverflow", + _1: typeof x === "object" ? x.NAME === "string" ? Css_AtomicTypes.TextOverflow.toString(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TextOverflow.toString(x) + }; + } + function textTransform(x) { + return { + TAG: 0, + _0: "textTransform", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TextTransform.toString(x) + }; + } + function top(x) { + return { + TAG: 0, + _0: "top", + _1: string_of_position(x) + }; + } + function transform(x) { + return { + TAG: 0, + _0: "transform", + _1: typeof x === "object" ? Css_AtomicTypes.Transform.toString(x) : "none" + }; + } + function transforms(x) { + return { + TAG: 0, + _0: "transform", + _1: join(Belt_Array.map(x, Css_AtomicTypes.Transform.toString), " ") + }; + } + function transformOrigin(x, y) { + return { + TAG: 0, + _0: "transformOrigin", + _1: Css_AtomicTypes.Length.toString(x) + (" " + Css_AtomicTypes.Length.toString(y)) + }; + } + function transformOrigin3d(x, y, z) { + return { + TAG: 0, + _0: "transformOrigin", + _1: Css_AtomicTypes.Length.toString(x) + (" " + (Css_AtomicTypes.Length.toString(y) + (" " + (Css_AtomicTypes.Length.toString(z) + " ")))) + }; + } + function unsafe(property, value) { + return { + TAG: 0, + _0: property, + _1: value + }; + } + function userSelect(x) { + return { + TAG: 0, + _0: "userSelect", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.UserSelect.toString(x) + }; + } + function verticalAlign(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "textTop" || x === "textBottom" || x === "baseline" || x === "super" || x === "top" || x === "sub" || x === "bottom" || x === "middle" ? Css_AtomicTypes.VerticalAlign.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "verticalAlign", + _1: tmp + }; + } + function visibility(x) { + return { + TAG: 0, + _0: "visibility", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.Visibility.toString(x) + }; + } + function scrollBehavior(x) { + return { + TAG: 0, + _0: "scrollBehavior", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.ScrollBehavior.toString(x) + }; + } + function overscrollBehavior(x) { + return { + TAG: 0, + _0: "overscrollBehavior", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.OverscrollBehavior.toString(x) + }; + } + function overflowAnchor(x) { + return { + TAG: 0, + _0: "overflowAnchor", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.OverflowAnchor.toString(x) + }; + } + function columnWidth(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.ColumnWidth.toString(x); + } + return { + TAG: 0, + _0: "columnWidth", + _1: tmp + }; + } + function caretColor(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : Css_AtomicTypes.Color.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "transparent" || x === "currentColor" ? Css_AtomicTypes.Color.toString(x) : Css_AtomicTypes.CaretColor.toString(x); + } + return { + TAG: 0, + _0: "caretColor", + _1: tmp + }; + } + function width(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.Width.toString(x); + } + return { + TAG: 0, + _0: "width", + _1: tmp + }; + } + function whiteSpace(x) { + return { + TAG: 0, + _0: "whiteSpace", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "nowrap" || x === "normal" || x === "breakSpaces" || x === "preWrap" || x === "preLine" || x === "pre" ? Css_AtomicTypes.WhiteSpace.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function wordBreak(x) { + return { + TAG: 0, + _0: "wordBreak", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "keepAll" || x === "normal" || x === "breakAll" ? Css_AtomicTypes.WordBreak.toString(x) : Css_AtomicTypes.Cascading.toString(x) + }; + } + function wordSpacing(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "percent" ? Css_AtomicTypes.Percentage.toString(x) : Css_AtomicTypes.Length.toString(x); + } else { + tmp = x === "zero" ? Css_AtomicTypes.Length.toString(x) : x === "normal" ? Css_AtomicTypes.WordSpacing.toString(x) : Css_AtomicTypes.Cascading.toString(x); + } + return { + TAG: 0, + _0: "wordSpacing", + _1: tmp + }; + } + function zIndex(x) { + return { + TAG: 0, + _0: "zIndex", + _1: x.toString() + }; + } + function media(query, rules) { + return { + TAG: 1, + _0: "@media " + query, + _1: rules + }; + } + function selector(selector$1, rules) { + return { + TAG: 1, + _0: selector$1, + _1: rules + }; + } + function active(param) { + return { + TAG: 2, + _0: "active", + _1: param + }; + } + function checked(param) { + return { + TAG: 2, + _0: "checked", + _1: param + }; + } + function $$default(param) { + return { + TAG: 2, + _0: "default", + _1: param + }; + } + function defined(param) { + return { + TAG: 2, + _0: "defined", + _1: param + }; + } + function disabled(param) { + return { + TAG: 2, + _0: "disabled", + _1: param + }; + } + function empty(param) { + return { + TAG: 2, + _0: "empty", + _1: param + }; + } + function enabled(param) { + return { + TAG: 2, + _0: "enabled", + _1: param + }; + } + function first(param) { + return { + TAG: 2, + _0: "first", + _1: param + }; + } + function firstChild(param) { + return { + TAG: 2, + _0: "first-child", + _1: param + }; + } + function firstOfType(param) { + return { + TAG: 2, + _0: "first-of-type", + _1: param + }; + } + function focus(param) { + return { + TAG: 2, + _0: "focus", + _1: param + }; + } + function focusVisible(param) { + return { + TAG: 2, + _0: "focus-visible", + _1: param + }; + } + function focusWithin(param) { + return { + TAG: 2, + _0: "focus-within", + _1: param + }; + } + function host(selector2, rules) { + if (selector2 !== void 0) { + return { + TAG: 3, + _0: "host", + _1: selector2, + _2: rules + }; + } else { + return { + TAG: 2, + _0: "host", + _1: rules + }; + } + } + function hover(param) { + return { + TAG: 2, + _0: "hover", + _1: param + }; + } + function indeterminate(param) { + return { + TAG: 2, + _0: "indeterminate", + _1: param + }; + } + function inRange(param) { + return { + TAG: 2, + _0: "in-range", + _1: param + }; + } + function invalid(param) { + return { + TAG: 2, + _0: "invalid", + _1: param + }; + } + function lang(code, rules) { + return { + TAG: 3, + _0: "lang", + _1: code, + _2: rules + }; + } + function lastChild(param) { + return { + TAG: 2, + _0: "last-child", + _1: param + }; + } + function lastOfType(param) { + return { + TAG: 2, + _0: "last-of-type", + _1: param + }; + } + function link(param) { + return { + TAG: 2, + _0: "link", + _1: param + }; + } + function not_(selector2, rules) { + return { + TAG: 3, + _0: "not", + _1: selector2, + _2: rules + }; + } + function toString(x) { + if (typeof x !== "object") { + if (x === "odd") { + return "odd"; + } else { + return "even"; + } + } + if (x.NAME !== "add") { + return x.VAL.toString() + "n"; + } + var match = x.VAL; + return match[0].toString() + ("n+" + match[1].toString()); + } + var Nth = { + toString + }; + function nthChild(x, rules) { + return { + TAG: 3, + _0: "nth-child", + _1: toString(x), + _2: rules + }; + } + function nthLastChild(x, rules) { + return { + TAG: 3, + _0: "nth-last-child", + _1: toString(x), + _2: rules + }; + } + function nthLastOfType(x, rules) { + return { + TAG: 3, + _0: "nth-last-of-type", + _1: toString(x), + _2: rules + }; + } + function nthOfType(x, rules) { + return { + TAG: 3, + _0: "nth-of-type", + _1: toString(x), + _2: rules + }; + } + function onlyChild(param) { + return { + TAG: 2, + _0: "only-child", + _1: param + }; + } + function onlyOfType(param) { + return { + TAG: 2, + _0: "only-of-type", + _1: param + }; + } + function optional(param) { + return { + TAG: 2, + _0: "optional", + _1: param + }; + } + function outOfRange(param) { + return { + TAG: 2, + _0: "out-of-range", + _1: param + }; + } + function readOnly(param) { + return { + TAG: 2, + _0: "read-only", + _1: param + }; + } + function readWrite(param) { + return { + TAG: 2, + _0: "read-write", + _1: param + }; + } + function required(param) { + return { + TAG: 2, + _0: "required", + _1: param + }; + } + function root(param) { + return { + TAG: 2, + _0: "root", + _1: param + }; + } + function scope(param) { + return { + TAG: 2, + _0: "scope", + _1: param + }; + } + function target(param) { + return { + TAG: 2, + _0: "target", + _1: param + }; + } + function valid(param) { + return { + TAG: 2, + _0: "valid", + _1: param + }; + } + function visited(param) { + return { + TAG: 2, + _0: "visited", + _1: param + }; + } + function after(__x) { + return selector("::after", __x); + } + function before(__x) { + return selector("::before", __x); + } + function firstLetter(__x) { + return selector("::first-letter", __x); + } + function firstLine(__x) { + return selector("::first-line", __x); + } + function selection(__x) { + return selector("::selection", __x); + } + function child(x, __x) { + return selector(" > " + x, __x); + } + function children(__x) { + return selector(" > *", __x); + } + function directSibling(__x) { + return selector(" + ", __x); + } + function placeholder(__x) { + return selector("::placeholder", __x); + } + function siblings(__x) { + return selector(" ~ ", __x); + } + function anyLink(__x) { + return selector(":any-link", __x); + } + var initial = Css_AtomicTypes.Cascading.initial; + var inherit_ = Css_AtomicTypes.Cascading.inherit_; + var unset = Css_AtomicTypes.Cascading.unset; + var $$var = Css_AtomicTypes.Var.$$var; + var varDefault = Css_AtomicTypes.Var.varDefault; + var pct = Css_AtomicTypes.Percentage.pct; + var ch = Css_AtomicTypes.Length.ch; + var cm = Css_AtomicTypes.Length.cm; + var em = Css_AtomicTypes.Length.em; + var ex = Css_AtomicTypes.Length.ex; + var mm = Css_AtomicTypes.Length.mm; + var pt = Css_AtomicTypes.Length.pt; + var px = Css_AtomicTypes.Length.px; + var pxFloat = Css_AtomicTypes.Length.pxFloat; + var rem = Css_AtomicTypes.Length.rem; + var vh = Css_AtomicTypes.Length.vh; + var vmin = Css_AtomicTypes.Length.vmin; + var vmax = Css_AtomicTypes.Length.vmax; + var zero = Css_AtomicTypes.Length.zero; + var deg = Css_AtomicTypes.Angle.deg; + var rad = Css_AtomicTypes.Angle.rad; + var grad = Css_AtomicTypes.Angle.grad; + var turn = Css_AtomicTypes.Angle.turn; + var ltr = Css_AtomicTypes.Direction.ltr; + var rtl = Css_AtomicTypes.Direction.rtl; + var absolute = Css_AtomicTypes.Position.absolute; + var relative = Css_AtomicTypes.Position.relative; + var $$static = Css_AtomicTypes.Position.$$static; + var sticky = Css_AtomicTypes.Position.sticky; + var horizontal = Css_AtomicTypes.Resize.horizontal; + var vertical = Css_AtomicTypes.Resize.vertical; + var smallCaps = Css_AtomicTypes.FontVariant.smallCaps; + var italic = Css_AtomicTypes.FontStyle.italic; + var oblique = Css_AtomicTypes.FontStyle.oblique; + var rgb = Css_AtomicTypes.Color.rgb; + var rgba = Css_AtomicTypes.Color.rgba; + var hsl = Css_AtomicTypes.Color.hsl; + var hsla = Css_AtomicTypes.Color.hsla; + var hex = Css_AtomicTypes.Color.hex; + var currentColor = Css_AtomicTypes.Color.currentColor; + var transparent = Css_AtomicTypes.Color.transparent; + var linear = Css_AtomicTypes.TimingFunction.linear; + var ease = Css_AtomicTypes.TimingFunction.ease; + var easeIn = Css_AtomicTypes.TimingFunction.easeIn; + var easeInOut = Css_AtomicTypes.TimingFunction.easeInOut; + var easeOut = Css_AtomicTypes.TimingFunction.easeOut; + var stepStart = Css_AtomicTypes.TimingFunction.stepStart; + var stepEnd = Css_AtomicTypes.TimingFunction.stepEnd; + var steps = Css_AtomicTypes.TimingFunction.steps; + var cubicBezier = Css_AtomicTypes.TimingFunction.cubicBezier; + var marginBox = Css_AtomicTypes.GeometryBox.marginBox; + var fillBox = Css_AtomicTypes.GeometryBox.fillBox; + var strokeBox = Css_AtomicTypes.GeometryBox.strokeBox; + var viewBox = Css_AtomicTypes.GeometryBox.viewBox; + var translate = Css_AtomicTypes.Transform.translate; + var translate3d = Css_AtomicTypes.Transform.translate3d; + var translateX = Css_AtomicTypes.Transform.translateX; + var translateY = Css_AtomicTypes.Transform.translateY; + var translateZ = Css_AtomicTypes.Transform.translateZ; + var scaleX = Css_AtomicTypes.Transform.scaleX; + var scaleY = Css_AtomicTypes.Transform.scaleY; + var scaleZ = Css_AtomicTypes.Transform.scaleZ; + var rotateX = Css_AtomicTypes.Transform.rotateX; + var rotateY = Css_AtomicTypes.Transform.rotateY; + var rotateZ = Css_AtomicTypes.Transform.rotateZ; + var scale = Css_AtomicTypes.Transform.scale; + var scale3d = Css_AtomicTypes.Transform.scale3d; + var skew = Css_AtomicTypes.Transform.skew; + var skewX = Css_AtomicTypes.Transform.skewX; + var skewY = Css_AtomicTypes.Transform.skewY; + var thin = Css_AtomicTypes.FontWeight.thin; + var extraLight = Css_AtomicTypes.FontWeight.extraLight; + var light = Css_AtomicTypes.FontWeight.light; + var medium = Css_AtomicTypes.FontWeight.medium; + var semiBold = Css_AtomicTypes.FontWeight.semiBold; + var bold = Css_AtomicTypes.FontWeight.bold; + var extraBold = Css_AtomicTypes.FontWeight.extraBold; + var lighter = Css_AtomicTypes.FontWeight.lighter; + var bolder = Css_AtomicTypes.FontWeight.bolder; + var linearGradient = Css_AtomicTypes.Gradient.linearGradient; + var repeatingLinearGradient = Css_AtomicTypes.Gradient.repeatingLinearGradient; + var radialGradient = Css_AtomicTypes.Gradient.radialGradient; + var repeatingRadialGradient = Css_AtomicTypes.Gradient.repeatingRadialGradient; + var conicGradient = Css_AtomicTypes.Gradient.conicGradient; + var areas = Css_AtomicTypes.GridTemplateAreas.areas; + var ident = Css_AtomicTypes.GridArea.ident; + var numIdent = Css_AtomicTypes.GridArea.numIdent; + var contextMenu = Css_AtomicTypes.Cursor.contextMenu; + var help = Css_AtomicTypes.Cursor.help; + var pointer = Css_AtomicTypes.Cursor.pointer; + var progress = Css_AtomicTypes.Cursor.progress; + var wait = Css_AtomicTypes.Cursor.wait; + var cell = Css_AtomicTypes.Cursor.cell; + var crosshair = Css_AtomicTypes.Cursor.crosshair; + var verticalText = Css_AtomicTypes.Cursor.verticalText; + var alias = Css_AtomicTypes.Cursor.alias; + var copy = Css_AtomicTypes.Cursor.copy; + var move = Css_AtomicTypes.Cursor.move; + var noDrop = Css_AtomicTypes.Cursor.noDrop; + var notAllowed = Css_AtomicTypes.Cursor.notAllowed; + var grab = Css_AtomicTypes.Cursor.grab; + var grabbing = Css_AtomicTypes.Cursor.grabbing; + var allScroll = Css_AtomicTypes.Cursor.allScroll; + var colResize = Css_AtomicTypes.Cursor.colResize; + var rowResize = Css_AtomicTypes.Cursor.rowResize; + var nResize = Css_AtomicTypes.Cursor.nResize; + var eResize = Css_AtomicTypes.Cursor.eResize; + var sResize = Css_AtomicTypes.Cursor.sResize; + var wResize = Css_AtomicTypes.Cursor.wResize; + var neResize = Css_AtomicTypes.Cursor.neResize; + var nwResize = Css_AtomicTypes.Cursor.nwResize; + var seResize = Css_AtomicTypes.Cursor.seResize; + var swResize = Css_AtomicTypes.Cursor.swResize; + var ewResize = Css_AtomicTypes.Cursor.ewResize; + var nsResize = Css_AtomicTypes.Cursor.nsResize; + var neswResize = Css_AtomicTypes.Cursor.neswResize; + var nwseResize = Css_AtomicTypes.Cursor.nwseResize; + var zoomIn = Css_AtomicTypes.Cursor.zoomIn; + var zoomOut = Css_AtomicTypes.Cursor.zoomOut; + function vw(x) { + return { + NAME: "vw", + VAL: x + }; + } + function fr(x) { + return { + NAME: "fr", + VAL: x + }; + } + function $neg(a, b) { + return { + NAME: "calc", + VAL: [ + "sub", + a, + b + ] + }; + } + function $plus(a, b) { + return { + NAME: "calc", + VAL: [ + "add", + a, + b + ] + }; + } + function $star(a, b) { + return { + NAME: "calc", + VAL: [ + "mult", + a, + b + ] + }; + } + var Calc = { + $neg, + $plus, + $star + }; + function size(x, y) { + return { + NAME: "size", + VAL: [ + x, + y + ] + }; + } + function count(x) { + return { + NAME: "count", + VAL: x + }; + } + function localUrl(x) { + return { + NAME: "localUrl", + VAL: x + }; + } + function rotate(a) { + return { + NAME: "rotate", + VAL: a + }; + } + function rotate3d(x, y, z, a) { + return { + NAME: "rotate3d", + VAL: [ + x, + y, + z, + a + ] + }; + } + function url(x) { + return { + NAME: "url", + VAL: x + }; + } + function flex3(grow, shrink, basis) { + return { + TAG: 0, + _0: "flex", + _1: grow.toString() + (" " + (shrink.toString() + (" " + (typeof basis === "object" || basis === "zero" ? Css_AtomicTypes.Length.toString(basis) : Css_AtomicTypes.FlexBasis.toString(basis))))) + }; + } + function flexBasis(x) { + return { + TAG: 0, + _0: "flexBasis", + _1: typeof x === "object" || x === "zero" ? Css_AtomicTypes.Length.toString(x) : Css_AtomicTypes.FlexBasis.toString(x) + }; + } + function order(x) { + return { + TAG: 0, + _0: "order", + _1: x.toString() + }; + } + function string_of_minmax(x) { + if (typeof x !== "object") { + if (x === "zero") { + return "0"; + } else if (x === "minContent") { + return "min-content"; + } else if (x === "maxContent") { + return "max-content"; + } else { + return "auto"; + } + } + var variant = x.NAME; + if (variant === "pxFloat") { + return x.VAL.toString() + "px"; + } + if (variant === "inch") { + return x.VAL.toString() + "in"; + } + if (variant === "vmax") { + return x.VAL.toString() + "vmax"; + } + if (variant === "vmin") { + return x.VAL.toString() + "vmin"; + } + if (variant === "percent") { + return x.VAL.toString() + "%"; + } + if (variant === "ch") { + return x.VAL.toString() + "ch"; + } + if (variant === "cm") { + return x.VAL.toString() + "cm"; + } + if (variant === "em") { + return x.VAL.toString() + "em"; + } + if (variant === "ex") { + return x.VAL.toString() + "ex"; + } + if (variant === "fr") { + return x.VAL.toString() + "fr"; + } + if (variant === "mm") { + return x.VAL.toString() + "mm"; + } + if (variant === "pc") { + return x.VAL.toString() + "pc"; + } + if (variant === "pt") { + return x.VAL.toString() + "pt"; + } + if (variant === "px") { + return x.VAL.toString() + "px"; + } + if (variant === "vh") { + return x.VAL.toString() + "vh"; + } + if (variant === "vw") { + return x.VAL.toString() + "vw"; + } + if (variant === "rem") { + return x.VAL.toString() + "rem"; + } + var match = x.VAL; + var match$1 = match[0]; + if (match$1 === "add") { + return "calc(" + (Css_AtomicTypes.Length.toString(match[1]) + (" + " + (Css_AtomicTypes.Length.toString(match[2]) + ")"))); + } else if (match$1 === "sub") { + return "calc(" + (Css_AtomicTypes.Length.toString(match[1]) + (" - " + (Css_AtomicTypes.Length.toString(match[2]) + ")"))); + } else { + return "calc(" + Css_AtomicTypes.Length.toString(match[1]) + " * " + Css_AtomicTypes.Length.toString(match[2]) + ")"; + } + } + function string_of_dimension(x) { + if (typeof x !== "object") { + if (x === "none") { + return "none"; + } else if (x === "zero") { + return "0"; + } else if (x === "minContent") { + return "min-content"; + } else if (x === "fitContent") { + return "fit-content"; + } else if (x === "maxContent") { + return "max-content"; + } else { + return "auto"; + } + } + var variant = x.NAME; + if (variant === "pxFloat") { + return x.VAL.toString() + "px"; + } + if (variant === "inch") { + return x.VAL.toString() + "in"; + } + if (variant === "vmax") { + return x.VAL.toString() + "vmax"; + } + if (variant === "vmin") { + return x.VAL.toString() + "vmin"; + } + if (variant === "minmax") { + var match = x.VAL; + return "minmax(" + string_of_minmax(match[0]) + "," + string_of_minmax(match[1]) + ")"; + } + if (variant === "percent") { + return x.VAL.toString() + "%"; + } + if (variant === "ch") { + return x.VAL.toString() + "ch"; + } + if (variant === "cm") { + return x.VAL.toString() + "cm"; + } + if (variant === "em") { + return x.VAL.toString() + "em"; + } + if (variant === "ex") { + return x.VAL.toString() + "ex"; + } + if (variant === "fr") { + return x.VAL.toString() + "fr"; + } + if (variant === "mm") { + return x.VAL.toString() + "mm"; + } + if (variant === "pc") { + return x.VAL.toString() + "pc"; + } + if (variant === "pt") { + return x.VAL.toString() + "pt"; + } + if (variant === "px") { + return x.VAL.toString() + "px"; + } + if (variant === "vh") { + return x.VAL.toString() + "vh"; + } + if (variant === "vw") { + return x.VAL.toString() + "vw"; + } + if (variant === "rem") { + return x.VAL.toString() + "rem"; + } + var match$1 = x.VAL; + var match$2 = match$1[0]; + if (match$2 === "add") { + return "calc(" + Css_AtomicTypes.Length.toString(match$1[1]) + " + " + Css_AtomicTypes.Length.toString(match$1[2]) + ")"; + } else if (match$2 === "sub") { + return "calc(" + Css_AtomicTypes.Length.toString(match$1[1]) + " - " + Css_AtomicTypes.Length.toString(match$1[2]) + ")"; + } else { + return "calc(" + Css_AtomicTypes.Length.toString(match$1[1]) + " * " + Css_AtomicTypes.Length.toString(match$1[2]) + ")"; + } + } + function gridLengthToJs(x) { + if (typeof x !== "object") { + if (x === "zero") { + return "0"; + } else if (x === "minContent") { + return "min-content"; + } else if (x === "maxContent") { + return "max-content"; + } else { + return "auto"; + } + } + var variant = x.NAME; + if (variant === "pxFloat") { + return x.VAL.toString() + "px"; + } + if (variant === "inch") { + return x.VAL.toString() + "in"; + } + if (variant === "vmax") { + return x.VAL.toString() + "vmax"; + } + if (variant === "vmin") { + return x.VAL.toString() + "vmin"; + } + if (variant === "minmax") { + var match = x.VAL; + return "minmax(" + string_of_minmax(match[0]) + "," + string_of_minmax(match[1]) + ")"; + } + if (variant === "percent") { + return x.VAL.toString() + "%"; + } + if (variant === "ch") { + return x.VAL.toString() + "ch"; + } + if (variant === "cm") { + return x.VAL.toString() + "cm"; + } + if (variant === "em") { + return x.VAL.toString() + "em"; + } + if (variant === "ex") { + return x.VAL.toString() + "ex"; + } + if (variant === "fr") { + return x.VAL.toString() + "fr"; + } + if (variant === "mm") { + return x.VAL.toString() + "mm"; + } + if (variant === "pc") { + return x.VAL.toString() + "pc"; + } + if (variant === "pt") { + return x.VAL.toString() + "pt"; + } + if (variant === "px") { + return x.VAL.toString() + "px"; + } + if (variant === "vh") { + return x.VAL.toString() + "vh"; + } + if (variant === "vw") { + return x.VAL.toString() + "vw"; + } + if (variant === "rem") { + return x.VAL.toString() + "rem"; + } + if (variant === "repeat") { + var match$1 = x.VAL; + return "repeat(" + Css_AtomicTypes.RepeatValue.toString(match$1[0]) + ", " + string_of_dimension(match$1[1]) + ")"; + } + var match$2 = x.VAL; + var match$3 = match$2[0]; + if (match$3 === "add") { + return "calc(" + Css_AtomicTypes.Length.toString(match$2[1]) + " + " + Css_AtomicTypes.Length.toString(match$2[2]) + ")"; + } else if (match$3 === "sub") { + return "calc(" + Css_AtomicTypes.Length.toString(match$2[1]) + " - " + Css_AtomicTypes.Length.toString(match$2[2]) + ")"; + } else { + return "calc(" + Css_AtomicTypes.Length.toString(match$2[1]) + " * " + Css_AtomicTypes.Length.toString(match$2[2]) + ")"; + } + } + function string_of_dimensions(dimensions) { + return join(Belt_Array.map(dimensions, gridLengthToJs), " "); + } + function gridTemplateColumns(dimensions) { + return { + TAG: 0, + _0: "gridTemplateColumns", + _1: string_of_dimensions(dimensions) + }; + } + function gridTemplateRows(dimensions) { + return { + TAG: 0, + _0: "gridTemplateRows", + _1: string_of_dimensions(dimensions) + }; + } + function gridAutoColumns(dimensions) { + return { + TAG: 0, + _0: "gridAutoColumns", + _1: string_of_dimension(dimensions) + }; + } + function gridAutoRows(dimensions) { + return { + TAG: 0, + _0: "gridAutoRows", + _1: string_of_dimension(dimensions) + }; + } + function gridArea(s) { + var tmp; + if (typeof s === "object") { + var variant = s.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(s) : Css_AtomicTypes.GridArea.toString(s); + } else { + tmp = s === "unset" || s === "inherit_" || s === "initial" ? Css_AtomicTypes.Cascading.toString(s) : Css_AtomicTypes.GridArea.toString(s); + } + return { + TAG: 0, + _0: "gridArea", + _1: tmp + }; + } + function gridArea2(s, s2) { + return { + TAG: 0, + _0: "gridArea", + _1: Css_AtomicTypes.GridArea.toString(s) + " / " + Css_AtomicTypes.GridArea.toString(s2) + }; + } + function gridArea3(s, s2, s3) { + return { + TAG: 0, + _0: "gridArea", + _1: Css_AtomicTypes.GridArea.toString(s) + " / " + Css_AtomicTypes.GridArea.toString(s2) + " / " + Css_AtomicTypes.GridArea.toString(s3) + }; + } + function gridArea4(s, s2, s3, s4) { + return { + TAG: 0, + _0: "gridArea", + _1: Css_AtomicTypes.GridArea.toString(s) + " / " + Css_AtomicTypes.GridArea.toString(s2) + " / " + Css_AtomicTypes.GridArea.toString(s3) + " / " + Css_AtomicTypes.GridArea.toString(s4) + }; + } + function gridTemplateAreas(l) { + return { + TAG: 0, + _0: "gridTemplateAreas", + _1: typeof l === "object" ? l.NAME === "areas" ? Css_AtomicTypes.GridTemplateAreas.toString(l) : Css_AtomicTypes.Var.toString(l) : l === "unset" || l === "inherit_" || l === "initial" ? Css_AtomicTypes.Cascading.toString(l) : Css_AtomicTypes.GridTemplateAreas.toString(l) + }; + } + function string_of_filter(x) { + if (typeof x !== "object") { + if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return "none"; + } + } + var variant = x.NAME; + if (variant !== "dropShadow") { + if (variant === "brightness") { + return "brightness(" + x.VAL.toString() + "%)"; + } else if (variant === "opacity") { + return "opacity(" + x.VAL.toString() + "%)"; + } else if (variant === "var" || variant === "varDefault") { + return Css_AtomicTypes.Var.toString(x); + } else if (variant === "grayscale") { + return "grayscale(" + x.VAL.toString() + "%)"; + } else if (variant === "sepia") { + return "sepia(" + x.VAL.toString() + "%)"; + } else if (variant === "saturate") { + return "saturate(" + x.VAL.toString() + "%)"; + } else if (variant === "url") { + return Css_AtomicTypes.Url.toString(x); + } else if (variant === "invert") { + return "invert(" + x.VAL.toString() + "%)"; + } else if (variant === "contrast") { + return "contrast(" + x.VAL.toString() + "%)"; + } else if (variant === "hueRotate") { + return "hue-rotate(" + Css_AtomicTypes.Angle.toString(x.VAL) + ")"; + } else { + return "blur(" + Css_AtomicTypes.Length.toString(x.VAL) + ")"; + } + } + var match = x.VAL; + return "drop-shadow(" + Css_AtomicTypes.Length.toString(match[0]) + " " + Css_AtomicTypes.Length.toString(match[1]) + " " + Css_AtomicTypes.Length.toString(match[2]) + " " + Css_AtomicTypes.Color.toString(match[3]) + ")"; + } + function filter(x) { + return { + TAG: 0, + _0: "filter", + _1: join(Belt_Array.map(x, string_of_filter), " ") + }; + } + function box(xOpt, yOpt, blurOpt, spreadOpt, insetOpt, color2) { + var x = xOpt !== void 0 ? xOpt : zero; + var y = yOpt !== void 0 ? yOpt : zero; + var blur = blurOpt !== void 0 ? blurOpt : zero; + var spread = spreadOpt !== void 0 ? spreadOpt : zero; + var inset = insetOpt !== void 0 ? insetOpt : false; + return { + NAME: "shadow", + VAL: Css_AtomicTypes.Length.toString(x) + " " + Css_AtomicTypes.Length.toString(y) + " " + Css_AtomicTypes.Length.toString(blur) + " " + Css_AtomicTypes.Length.toString(spread) + " " + string_of_color(color2) + (inset ? " inset" : "") + }; + } + function text(xOpt, yOpt, blurOpt, color2) { + var x = xOpt !== void 0 ? xOpt : zero; + var y = yOpt !== void 0 ? yOpt : zero; + var blur = blurOpt !== void 0 ? blurOpt : zero; + return { + NAME: "shadow", + VAL: Css_AtomicTypes.Length.toString(x) + " " + Css_AtomicTypes.Length.toString(y) + " " + Css_AtomicTypes.Length.toString(blur) + " " + string_of_color(color2) + }; + } + function toString$1(x) { + if (typeof x === "object") { + return x.VAL; + } else { + return "none"; + } + } + var Shadow = { + box, + text, + toString: toString$1 + }; + function boxShadow(x) { + return { + TAG: 0, + _0: "boxShadow", + _1: typeof x === "object" ? x.NAME === "shadow" ? toString$1(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : toString$1(x) + }; + } + function boxShadows(x) { + return { + TAG: 0, + _0: "boxShadow", + _1: join(Belt_Array.map(x, toString$1), ", ") + }; + } + function string_of_borderstyle(x) { + if (typeof x === "object") { + return Css_AtomicTypes.Var.toString(x); + } else if (x === "unset" || x === "inherit_" || x === "initial") { + return Css_AtomicTypes.Cascading.toString(x); + } else { + return Css_AtomicTypes.BorderStyle.toString(x); + } + } + function border(px2, style, color2) { + return { + TAG: 0, + _0: "border", + _1: Css_AtomicTypes.Length.toString(px2) + " " + string_of_borderstyle(style) + " " + string_of_color(color2) + }; + } + function borderStyle(x) { + return { + TAG: 0, + _0: "borderStyle", + _1: string_of_borderstyle(x) + }; + } + function borderLeft(px2, style, color2) { + return { + TAG: 0, + _0: "borderLeft", + _1: Css_AtomicTypes.Length.toString(px2) + " " + string_of_borderstyle(style) + " " + string_of_color(color2) + }; + } + function borderLeftStyle(x) { + return { + TAG: 0, + _0: "borderLeftStyle", + _1: string_of_borderstyle(x) + }; + } + function borderRight(px2, style, color2) { + return { + TAG: 0, + _0: "borderRight", + _1: Css_AtomicTypes.Length.toString(px2) + " " + string_of_borderstyle(style) + " " + string_of_color(color2) + }; + } + function borderRightStyle(x) { + return { + TAG: 0, + _0: "borderRightStyle", + _1: string_of_borderstyle(x) + }; + } + function borderTop(px2, style, color2) { + return { + TAG: 0, + _0: "borderTop", + _1: Css_AtomicTypes.Length.toString(px2) + " " + string_of_borderstyle(style) + " " + string_of_color(color2) + }; + } + function borderTopStyle(x) { + return { + TAG: 0, + _0: "borderTopStyle", + _1: string_of_borderstyle(x) + }; + } + function borderBottom(px2, style, color2) { + return { + TAG: 0, + _0: "borderBottom", + _1: Css_AtomicTypes.Length.toString(px2) + " " + string_of_borderstyle(style) + " " + string_of_color(color2) + }; + } + function borderBottomStyle(x) { + return { + TAG: 0, + _0: "borderBottomStyle", + _1: string_of_borderstyle(x) + }; + } + function background(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "linearGradient" || variant === "radialGradient" || variant === "repeatingLinearGradient" || variant === "repeatingRadialGradient" || variant === "conicGradient" ? Css_AtomicTypes.Gradient.toString(x) : variant === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Color.toString(x); + } else { + tmp = x === "transparent" || x === "currentColor" ? Css_AtomicTypes.Color.toString(x) : "none"; + } + return { + TAG: 0, + _0: "background", + _1: tmp + }; + } + function backgrounds(x) { + return { + TAG: 0, + _0: "background", + _1: join(Belt_Array.map(x, function(item) { + if (typeof item !== "object") { + if (item === "transparent" || item === "currentColor") { + return Css_AtomicTypes.Color.toString(item); + } else { + return "none"; + } + } + var variant = item.NAME; + if (variant === "linearGradient" || variant === "radialGradient" || variant === "repeatingLinearGradient" || variant === "repeatingRadialGradient" || variant === "conicGradient") { + return Css_AtomicTypes.Gradient.toString(item); + } else if (variant === "url") { + return Css_AtomicTypes.Url.toString(item); + } else { + return Css_AtomicTypes.Color.toString(item); + } + }), ", ") + }; + } + function backgroundSize(x) { + var tmp; + if (typeof x === "object") { + var match = x.VAL; + tmp = Css_AtomicTypes.Length.toString(match[0]) + " " + Css_AtomicTypes.Length.toString(match[1]); + } else { + tmp = x === "cover" ? "cover" : x === "contain" ? "contain" : "auto"; + } + return { + TAG: 0, + _0: "backgroundSize", + _1: tmp + }; + } + function fontFace(fontFamily2, src, fontStyle2, fontWeight2, fontDisplay, param) { + var fontStyle$1 = Js_option.map(function(value) { + return Css_AtomicTypes.FontStyle.toString(value); + }, fontStyle2); + var src$1 = join(Belt_Array.map(src, function(x) { + if (x.NAME === "url") { + return 'url("' + x.VAL + '")'; + } else { + return 'local("' + x.VAL + '")'; + } + }), ", "); + var fontStyle$2 = Belt_Option.mapWithDefault(fontStyle$1, "", function(s) { + return "font-style: " + s + ";"; + }); + var fontWeight$1 = Belt_Option.mapWithDefault(fontWeight2, "", function(w) { + return "font-weight: " + (typeof w === "object" ? w.NAME === "num" ? Css_AtomicTypes.FontWeight.toString(w) : Css_AtomicTypes.Var.toString(w) : w === "unset" || w === "inherit_" || w === "initial" ? Css_AtomicTypes.Cascading.toString(w) : Css_AtomicTypes.FontWeight.toString(w)) + ";"; + }); + var fontDisplay$1 = Belt_Option.mapWithDefault(fontDisplay, "", function(f) { + return "font-display: " + Css_AtomicTypes.FontDisplay.toString(f) + ";"; + }); + return "@font-face {\r\n font-family: " + fontFamily2 + ";\r\n src: " + src$1 + ";\r\n " + fontStyle$2 + "\r\n " + fontWeight$1 + "\r\n " + fontDisplay$1 + "\r\n }"; + } + function textDecoration(x) { + return { + TAG: 0, + _0: "textDecoration", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "none" ? "none" : x === "initial" ? "initial" : x === "inherit_" ? "inherit" : x === "underline" ? "underline" : x === "lineThrough" ? "line-through" : x === "unset" ? "unset" : "overline" + }; + } + function textShadow(x) { + return { + TAG: 0, + _0: "textShadow", + _1: typeof x === "object" ? x.NAME === "shadow" ? toString$1(x) : Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : toString$1(x) + }; + } + function textShadows(x) { + return { + TAG: 0, + _0: "textShadow", + _1: join(Belt_Array.map(x, toString$1), ", ") + }; + } + function transformStyle(x) { + return { + TAG: 0, + _0: "transformStyle", + _1: typeof x === "object" ? Css_AtomicTypes.Var.toString(x) : x === "unset" || x === "inherit_" || x === "initial" ? Css_AtomicTypes.Cascading.toString(x) : Css_AtomicTypes.TransformStyle.toString(x) + }; + } + function shorthand(durationOpt, delayOpt, timingFunctionOpt, property) { + var duration = durationOpt !== void 0 ? durationOpt : 0; + var delay = delayOpt !== void 0 ? delayOpt : 0; + var timingFunction = timingFunctionOpt !== void 0 ? timingFunctionOpt : "ease"; + return { + NAME: "value", + VAL: duration.toString() + "ms " + Css_AtomicTypes.TimingFunction.toString(timingFunction) + " " + (delay.toString() + "ms") + " " + property + }; + } + function toString$2(x) { + return x.VAL; + } + var Transition = { + shorthand, + toString: toString$2 + }; + function transitionValue(x) { + return { + TAG: 0, + _0: "transition", + _1: x.VAL + }; + } + function transitionList(x) { + return { + TAG: 0, + _0: "transition", + _1: join(Belt_Array.map(x, toString$2), ", ") + }; + } + function transition(duration, delay, timingFunction, property) { + var x = shorthand(duration, delay, timingFunction, property); + return { + TAG: 0, + _0: "transition", + _1: x.VAL + }; + } + function transitionDelay(i) { + return { + TAG: 0, + _0: "transitionDelay", + _1: i.toString() + "ms" + }; + } + function transitionDuration(i) { + return { + TAG: 0, + _0: "transitionDuration", + _1: i.toString() + "ms" + }; + } + function transitionTimingFunction(x) { + return { + TAG: 0, + _0: "transitionTimingFunction", + _1: Css_AtomicTypes.TimingFunction.toString(x) + }; + } + function transitionProperty(x) { + return { + TAG: 0, + _0: "transitionProperty", + _1: x + }; + } + function shorthand$1(durationOpt, delayOpt, directionOpt, timingFunctionOpt, fillModeOpt, playStateOpt, iterationCountOpt, name) { + var duration = durationOpt !== void 0 ? durationOpt : 0; + var delay = delayOpt !== void 0 ? delayOpt : 0; + var direction2 = directionOpt !== void 0 ? directionOpt : "normal"; + var timingFunction = timingFunctionOpt !== void 0 ? timingFunctionOpt : "ease"; + var fillMode = fillModeOpt !== void 0 ? fillModeOpt : "none"; + var playState = playStateOpt !== void 0 ? playStateOpt : "running"; + var iterationCount = iterationCountOpt !== void 0 ? iterationCountOpt : { + NAME: "count", + VAL: 1 + }; + return { + NAME: "value", + VAL: name + " " + (duration.toString() + "ms") + " " + Css_AtomicTypes.TimingFunction.toString(timingFunction) + " " + (delay.toString() + "ms") + " " + Css_AtomicTypes.AnimationIterationCount.toString(iterationCount) + " " + Css_AtomicTypes.AnimationDirection.toString(direction2) + " " + Css_AtomicTypes.AnimationFillMode.toString(fillMode) + " " + Css_AtomicTypes.AnimationPlayState.toString(playState) + }; + } + function toString$3(x) { + return x.VAL; + } + var Animation = { + shorthand: shorthand$1, + toString: toString$3 + }; + function animationValue(x) { + return { + TAG: 0, + _0: "animation", + _1: x.VAL + }; + } + function animation(duration, delay, direction2, timingFunction, fillMode, playState, iterationCount, name) { + var x = shorthand$1(duration, delay, direction2, timingFunction, fillMode, playState, iterationCount, name); + return { + TAG: 0, + _0: "animation", + _1: x.VAL + }; + } + function animations(x) { + return { + TAG: 0, + _0: "animation", + _1: join(Belt_Array.map(x, toString$3), ", ") + }; + } + function animationName(x) { + return { + TAG: 0, + _0: "animationName", + _1: x + }; + } + function fill(x) { + var tmp; + if (typeof x === "object") { + var variant = x.NAME; + tmp = variant === "var" || variant === "varDefault" ? Css_AtomicTypes.Var.toString(x) : variant === "url" ? Css_AtomicTypes.Url.toString(x) : Css_AtomicTypes.Color.toString(x); + } else { + tmp = x === "transparent" || x === "currentColor" ? Css_AtomicTypes.Color.toString(x) : Curry._1(Css_AtomicTypes.SVG.Fill.toString, x); + } + return { + TAG: 0, + _0: "fill", + _1: tmp + }; + } + function fillOpacity(opacity2) { + return { + TAG: 0, + _0: "fillOpacity", + _1: opacity2.toString() + }; + } + function fillRule(x) { + return { + TAG: 0, + _0: "fillRule", + _1: x === "evenodd" ? "evenodd" : "nonzero" + }; + } + function stroke(x) { + return { + TAG: 0, + _0: "stroke", + _1: string_of_color(x) + }; + } + function strokeDasharray(x) { + return { + TAG: 0, + _0: "strokeDasharray", + _1: typeof x === "object" ? join(Belt_Array.map(x.VAL, string_of_dasharray), " ") : "none" + }; + } + function strokeWidth(x) { + return { + TAG: 0, + _0: "strokeWidth", + _1: Css_AtomicTypes.Length.toString(x) + }; + } + function strokeOpacity(opacity2) { + return { + TAG: 0, + _0: "strokeOpacity", + _1: opacity2.toString() + }; + } + function strokeMiterlimit(x) { + return { + TAG: 0, + _0: "strokeMiterlimit", + _1: x.toString() + }; + } + function strokeLinecap(x) { + return { + TAG: 0, + _0: "strokeLinecap", + _1: x === "square" ? "square" : x === "round" ? "round" : "butt" + }; + } + function strokeLinejoin(x) { + return { + TAG: 0, + _0: "strokeLinejoin", + _1: x === "miter" ? "miter" : x === "bevel" ? "bevel" : "round" + }; + } + function stopColor(x) { + return { + TAG: 0, + _0: "stopColor", + _1: string_of_color(x) + }; + } + function stopOpacity(x) { + return { + TAG: 0, + _0: "stopOpacity", + _1: x.toString() + }; + } + function touchAction(x) { + return { + TAG: 0, + _0: "touchAction", + _1: Css_AtomicTypes.TouchAction.toString(x) + }; + } + var Types; + var wordWrap = overflowWrap; + var auto = "auto"; + var none = "none"; + var text$1 = "text"; + var fixed = "fixed"; + var isolate = "isolate"; + var hidden = "hidden"; + var visible = "visible"; + var scroll = "scroll"; + var local = "local"; + var paddingBox = "paddingBox"; + var borderBox = "borderBox"; + var contentBox = "contentBox"; + var noRepeat = "noRepeat"; + var space = "space"; + var repeat = "repeat"; + var minmax = "minmax"; + var repeatX = "repeatX"; + var repeatY = "repeatY"; + var contain = "contain"; + var cover = "cover"; + var row = "row"; + var rowReverse = "rowReverse"; + var column = "column"; + var columnReverse = "columnReverse"; + var wrap = "wrap"; + var nowrap = "nowrap"; + var wrapReverse = "wrapReverse"; + var inline = "inline"; + var block = "block"; + var contents = "contents"; + var flexBox = "flex"; + var grid = "grid"; + var inlineBlock = "inlineBlock"; + var inlineFlex = "inlineFlex"; + var inlineGrid = "inlineGrid"; + var inlineTable = "inlineTable"; + var listItem = "listItem"; + var runIn = "runIn"; + var table = "table"; + var tableCaption = "tableCaption"; + var tableColumnGroup = "tableColumnGroup"; + var tableHeaderGroup = "tableHeaderGroup"; + var tableFooterGroup = "tableFooterGroup"; + var tableRowGroup = "tableRowGroup"; + var tableCell = "tableCell"; + var tableColumn = "tableColumn"; + var tableRow = "tableRow"; + var flexStart = "flexStart"; + var flexEnd = "flexEnd"; + var center = "center"; + var stretch = "stretch"; + var spaceBetween = "spaceBetween"; + var spaceAround = "spaceAround"; + var spaceEvenly = "spaceEvenly"; + var baseline = "baseline"; + var forwards = "forwards"; + var backwards = "backwards"; + var both = "both"; + var infinite = "infinite"; + var paused = "paused"; + var running = "running"; + var inside = "inside"; + var outside = "outside"; + var solid = "solid"; + var dotted = "dotted"; + var dashed = "dashed"; + var underline = "underline"; + var overline = "overline"; + var lineThrough = "lineThrough"; + var clip = "clip"; + var ellipsis = "ellipsis"; + var wavy = "wavy"; + var $$double = "double"; + var uppercase = "uppercase"; + var lowercase = "lowercase"; + var capitalize = "capitalize"; + var sub = "sub"; + var $$super = "super"; + var textTop = "textTop"; + var textBottom = "textBottom"; + var middle = "middle"; + var normal = "normal"; + var breakAll = "breakAll"; + var keepAll = "keepAll"; + var breakWord = "breakWord"; + var reverse = "reverse"; + var alternate = "alternate"; + var alternateReverse = "alternateReverse"; + var fill$1 = "fill"; + var content = "content"; + var maxContent = "maxContent"; + var minContent = "minContent"; + var fitContent = "fitContent"; + var all = "all"; + var round = "round"; + var miter = "miter"; + var bevel = "bevel"; + var butt = "butt"; + var square = "square"; + var panX = "panX"; + var panY = "panY"; + var panLeft = "panLeft"; + var panRight = "panRight"; + var panUp = "panUp"; + var panDown = "panDown"; + var pinchZoom = "pinchZoom"; + var manipulation = "manipulation"; + var transitions = transitionList; + var SVG = { + fill, + fillRule, + fillOpacity, + stroke, + strokeDasharray, + strokeLinecap, + strokeLinejoin, + strokeMiterlimit, + strokeWidth, + strokeOpacity, + stopColor, + stopOpacity + }; + exports.Types = Types; + exports.Make = Make; + exports.toJson = toJson; + exports.important = important; + exports.label = label; + exports.Shadow = Shadow; + exports.unsafe = unsafe; + exports.alignContent = alignContent; + exports.alignItems = alignItems; + exports.alignSelf = alignSelf; + exports.animationDelay = animationDelay; + exports.animationDirection = animationDirection; + exports.animationDuration = animationDuration; + exports.animationFillMode = animationFillMode; + exports.animationIterationCount = animationIterationCount; + exports.animationPlayState = animationPlayState; + exports.animationTimingFunction = animationTimingFunction; + exports.backdropFilter = backdropFilter; + exports.backfaceVisibility = backfaceVisibility; + exports.backgroundAttachment = backgroundAttachment; + exports.backgroundColor = backgroundColor; + exports.backgroundClip = backgroundClip; + exports.backgroundImage = backgroundImage; + exports.maskImage = maskImage; + exports.backgroundOrigin = backgroundOrigin; + exports.backgroundPosition = backgroundPosition; + exports.backgroundPositions = backgroundPositions; + exports.backgroundPosition4 = backgroundPosition4; + exports.maskPosition = maskPosition; + exports.maskPositions = maskPositions; + exports.backgroundRepeat = backgroundRepeat; + exports.borderBottom = borderBottom; + exports.borderBottomColor = borderBottomColor; + exports.borderBottomLeftRadius = borderBottomLeftRadius; + exports.borderBottomRightRadius = borderBottomRightRadius; + exports.borderBottomStyle = borderBottomStyle; + exports.borderBottomWidth = borderBottomWidth; + exports.borderCollapse = borderCollapse; + exports.borderColor = borderColor; + exports.borderLeft = borderLeft; + exports.borderLeftColor = borderLeftColor; + exports.borderLeftStyle = borderLeftStyle; + exports.borderLeftWidth = borderLeftWidth; + exports.borderRight = borderRight; + exports.borderRightColor = borderRightColor; + exports.borderRightStyle = borderRightStyle; + exports.borderRightWidth = borderRightWidth; + exports.borderRadius = borderRadius; + exports.borderRadius4 = borderRadius4; + exports.borderSpacing = borderSpacing; + exports.borderStyle = borderStyle; + exports.borderTopColor = borderTopColor; + exports.borderTopLeftRadius = borderTopLeftRadius; + exports.borderTopRightRadius = borderTopRightRadius; + exports.borderTopStyle = borderTopStyle; + exports.borderTopWidth = borderTopWidth; + exports.borderWidth = borderWidth; + exports.bottom = bottom; + exports.boxSizing = boxSizing; + exports.boxShadow = boxShadow; + exports.boxShadows = boxShadows; + exports.clear = clear; + exports.clipPath = clipPath; + exports.color = color; + exports.columnCount = columnCount; + exports.contentRule = contentRule; + exports.contentRules = contentRules; + exports.counterIncrement = counterIncrement; + exports.countersIncrement = countersIncrement; + exports.counterReset = counterReset; + exports.countersReset = countersReset; + exports.counterSet = counterSet; + exports.countersSet = countersSet; + exports.cursor = cursor; + exports.direction = direction; + exports.display = display; + exports.flex = flex; + exports.flexBasis = flexBasis; + exports.flexDirection = flexDirection; + exports.flexGrow = flexGrow; + exports.flexShrink = flexShrink; + exports.flexWrap = flexWrap; + exports.$$float = $$float; + exports.fontFamily = fontFamily; + exports.fontFamilies = fontFamilies; + exports.fontSize = fontSize; + exports.fontStyle = fontStyle; + exports.fontVariant = fontVariant; + exports.fontWeight = fontWeight; + exports.gridArea = gridArea; + exports.gridArea2 = gridArea2; + exports.gridArea3 = gridArea3; + exports.gridArea4 = gridArea4; + exports.gridAutoFlow = gridAutoFlow; + exports.gridColumn = gridColumn; + exports.gridColumnEnd = gridColumnEnd; + exports.columnGap = columnGap; + exports.scrollBehavior = scrollBehavior; + exports.overscrollBehavior = overscrollBehavior; + exports.overflowAnchor = overflowAnchor; + exports.columnWidth = columnWidth; + exports.caretColor = caretColor; + exports.gridColumnGap = gridColumnGap; + exports.gridColumnStart = gridColumnStart; + exports.gap = gap; + exports.gap2 = gap2; + exports.gridGap = gridGap; + exports.gridRow = gridRow; + exports.gridRowEnd = gridRowEnd; + exports.gridRowGap = gridRowGap; + exports.rowGap = rowGap; + exports.gridRowStart = gridRowStart; + exports.gridTemplateAreas = gridTemplateAreas; + exports.height = height; + exports.justifyContent = justifyContent; + exports.justifyItems = justifyItems; + exports.justifySelf = justifySelf; + exports.left = left; + exports.letterSpacing = letterSpacing; + exports.lineHeight = lineHeight; + exports.listStyle = listStyle; + exports.listStyleImage = listStyleImage; + exports.listStyleType = listStyleType; + exports.listStylePosition = listStylePosition; + exports.margin = margin; + exports.margin2 = margin2; + exports.margin3 = margin3; + exports.margin4 = margin4; + exports.marginLeft = marginLeft; + exports.marginRight = marginRight; + exports.marginTop = marginTop; + exports.marginBottom = marginBottom; + exports.maxHeight = maxHeight; + exports.maxWidth = maxWidth; + exports.minHeight = minHeight; + exports.minWidth = minWidth; + exports.objectFit = objectFit; + exports.objectPosition = objectPosition; + exports.opacity = opacity; + exports.order = order; + exports.outline = outline; + exports.outlineColor = outlineColor; + exports.outlineOffset = outlineOffset; + exports.outlineStyle = outlineStyle; + exports.outlineWidth = outlineWidth; + exports.overflow = overflow; + exports.overflowX = overflowX; + exports.overflowY = overflowY; + exports.overflowWrap = overflowWrap; + exports.padding = padding; + exports.padding2 = padding2; + exports.padding3 = padding3; + exports.padding4 = padding4; + exports.paddingLeft = paddingLeft; + exports.paddingRight = paddingRight; + exports.paddingTop = paddingTop; + exports.paddingBottom = paddingBottom; + exports.perspective = perspective; + exports.perspectiveOrigin = perspectiveOrigin; + exports.pointerEvents = pointerEvents; + exports.position = position; + exports.isolation = isolation; + exports.resize = resize; + exports.right = right; + exports.tableLayout = tableLayout; + exports.textAlign = textAlign; + exports.textDecorationColor = textDecorationColor; + exports.textDecorationLine = textDecorationLine; + exports.textDecorationStyle = textDecorationStyle; + exports.textIndent = textIndent; + exports.textOverflow = textOverflow; + exports.textShadow = textShadow; + exports.textShadows = textShadows; + exports.textTransform = textTransform; + exports.top = top; + exports.transform = transform; + exports.transforms = transforms; + exports.transformOrigin = transformOrigin; + exports.transformOrigin3d = transformOrigin3d; + exports.transitionDelay = transitionDelay; + exports.transitionDuration = transitionDuration; + exports.transitionProperty = transitionProperty; + exports.transformStyle = transformStyle; + exports.transitionTimingFunction = transitionTimingFunction; + exports.userSelect = userSelect; + exports.verticalAlign = verticalAlign; + exports.visibility = visibility; + exports.width = width; + exports.whiteSpace = whiteSpace; + exports.wordBreak = wordBreak; + exports.wordSpacing = wordSpacing; + exports.wordWrap = wordWrap; + exports.zIndex = zIndex; + exports.selector = selector; + exports.media = media; + exports.active = active; + exports.checked = checked; + exports.$$default = $$default; + exports.default = $$default; + exports.__esModule = true; + exports.defined = defined; + exports.disabled = disabled; + exports.empty = empty; + exports.enabled = enabled; + exports.first = first; + exports.firstChild = firstChild; + exports.firstOfType = firstOfType; + exports.focus = focus; + exports.focusVisible = focusVisible; + exports.focusWithin = focusWithin; + exports.host = host; + exports.hover = hover; + exports.indeterminate = indeterminate; + exports.inRange = inRange; + exports.invalid = invalid; + exports.lang = lang; + exports.lastChild = lastChild; + exports.lastOfType = lastOfType; + exports.link = link; + exports.not_ = not_; + exports.Nth = Nth; + exports.nthChild = nthChild; + exports.nthLastChild = nthLastChild; + exports.nthLastOfType = nthLastOfType; + exports.nthOfType = nthOfType; + exports.onlyChild = onlyChild; + exports.onlyOfType = onlyOfType; + exports.optional = optional; + exports.outOfRange = outOfRange; + exports.readOnly = readOnly; + exports.readWrite = readWrite; + exports.required = required; + exports.root = root; + exports.scope = scope; + exports.target = target; + exports.valid = valid; + exports.visited = visited; + exports.after = after; + exports.before = before; + exports.firstLetter = firstLetter; + exports.firstLine = firstLine; + exports.placeholder = placeholder; + exports.selection = selection; + exports.child = child; + exports.children = children; + exports.directSibling = directSibling; + exports.siblings = siblings; + exports.anyLink = anyLink; + exports.initial = initial; + exports.inherit_ = inherit_; + exports.unset = unset; + exports.$$var = $$var; + exports.varDefault = varDefault; + exports.auto = auto; + exports.none = none; + exports.text = text$1; + exports.pct = pct; + exports.ch = ch; + exports.cm = cm; + exports.em = em; + exports.ex = ex; + exports.mm = mm; + exports.pt = pt; + exports.px = px; + exports.pxFloat = pxFloat; + exports.rem = rem; + exports.vh = vh; + exports.vmin = vmin; + exports.vmax = vmax; + exports.zero = zero; + exports.deg = deg; + exports.rad = rad; + exports.grad = grad; + exports.turn = turn; + exports.ltr = ltr; + exports.rtl = rtl; + exports.absolute = absolute; + exports.relative = relative; + exports.$$static = $$static; + exports.fixed = fixed; + exports.sticky = sticky; + exports.isolate = isolate; + exports.horizontal = horizontal; + exports.vertical = vertical; + exports.smallCaps = smallCaps; + exports.italic = italic; + exports.oblique = oblique; + exports.hidden = hidden; + exports.visible = visible; + exports.scroll = scroll; + exports.rgb = rgb; + exports.rgba = rgba; + exports.hsl = hsl; + exports.hsla = hsla; + exports.hex = hex; + exports.transparent = transparent; + exports.currentColor = currentColor; + exports.local = local; + exports.paddingBox = paddingBox; + exports.borderBox = borderBox; + exports.contentBox = contentBox; + exports.noRepeat = noRepeat; + exports.space = space; + exports.repeat = repeat; + exports.minmax = minmax; + exports.repeatX = repeatX; + exports.repeatY = repeatY; + exports.contain = contain; + exports.cover = cover; + exports.row = row; + exports.rowReverse = rowReverse; + exports.column = column; + exports.columnReverse = columnReverse; + exports.wrap = wrap; + exports.nowrap = nowrap; + exports.wrapReverse = wrapReverse; + exports.inline = inline; + exports.block = block; + exports.contents = contents; + exports.flexBox = flexBox; + exports.grid = grid; + exports.inlineBlock = inlineBlock; + exports.inlineFlex = inlineFlex; + exports.inlineGrid = inlineGrid; + exports.inlineTable = inlineTable; + exports.listItem = listItem; + exports.runIn = runIn; + exports.table = table; + exports.tableCaption = tableCaption; + exports.tableColumnGroup = tableColumnGroup; + exports.tableHeaderGroup = tableHeaderGroup; + exports.tableFooterGroup = tableFooterGroup; + exports.tableRowGroup = tableRowGroup; + exports.tableCell = tableCell; + exports.tableColumn = tableColumn; + exports.tableRow = tableRow; + exports.flexStart = flexStart; + exports.flexEnd = flexEnd; + exports.center = center; + exports.stretch = stretch; + exports.spaceBetween = spaceBetween; + exports.spaceAround = spaceAround; + exports.spaceEvenly = spaceEvenly; + exports.baseline = baseline; + exports.forwards = forwards; + exports.backwards = backwards; + exports.both = both; + exports.infinite = infinite; + exports.count = count; + exports.paused = paused; + exports.running = running; + exports.inside = inside; + exports.outside = outside; + exports.solid = solid; + exports.dotted = dotted; + exports.dashed = dashed; + exports.underline = underline; + exports.overline = overline; + exports.lineThrough = lineThrough; + exports.clip = clip; + exports.ellipsis = ellipsis; + exports.wavy = wavy; + exports.$$double = $$double; + exports.uppercase = uppercase; + exports.lowercase = lowercase; + exports.capitalize = capitalize; + exports.sub = sub; + exports.$$super = $$super; + exports.textTop = textTop; + exports.textBottom = textBottom; + exports.middle = middle; + exports.normal = normal; + exports.breakAll = breakAll; + exports.keepAll = keepAll; + exports.breakWord = breakWord; + exports.reverse = reverse; + exports.alternate = alternate; + exports.alternateReverse = alternateReverse; + exports.fill = fill$1; + exports.content = content; + exports.maxContent = maxContent; + exports.minContent = minContent; + exports.fitContent = fitContent; + exports.all = all; + exports.round = round; + exports.miter = miter; + exports.bevel = bevel; + exports.butt = butt; + exports.square = square; + exports.panX = panX; + exports.panY = panY; + exports.panLeft = panLeft; + exports.panRight = panRight; + exports.panUp = panUp; + exports.panDown = panDown; + exports.pinchZoom = pinchZoom; + exports.manipulation = manipulation; + exports.thin = thin; + exports.extraLight = extraLight; + exports.light = light; + exports.medium = medium; + exports.semiBold = semiBold; + exports.bold = bold; + exports.extraBold = extraBold; + exports.lighter = lighter; + exports.bolder = bolder; + exports.fr = fr; + exports.vw = vw; + exports.localUrl = localUrl; + exports.url = url; + exports.linear = linear; + exports.ease = ease; + exports.easeIn = easeIn; + exports.easeOut = easeOut; + exports.easeInOut = easeInOut; + exports.stepStart = stepStart; + exports.stepEnd = stepEnd; + exports.steps = steps; + exports.cubicBezier = cubicBezier; + exports.marginBox = marginBox; + exports.fillBox = fillBox; + exports.strokeBox = strokeBox; + exports.viewBox = viewBox; + exports.translate = translate; + exports.translate3d = translate3d; + exports.translateX = translateX; + exports.translateY = translateY; + exports.translateZ = translateZ; + exports.scale = scale; + exports.scale3d = scale3d; + exports.scaleX = scaleX; + exports.scaleY = scaleY; + exports.scaleZ = scaleZ; + exports.rotate = rotate; + exports.rotate3d = rotate3d; + exports.rotateX = rotateX; + exports.rotateY = rotateY; + exports.rotateZ = rotateZ; + exports.skew = skew; + exports.skewX = skewX; + exports.skewY = skewY; + exports.linearGradient = linearGradient; + exports.repeatingLinearGradient = repeatingLinearGradient; + exports.radialGradient = radialGradient; + exports.repeatingRadialGradient = repeatingRadialGradient; + exports.conicGradient = conicGradient; + exports.areas = areas; + exports.ident = ident; + exports.numIdent = numIdent; + exports.contextMenu = contextMenu; + exports.help = help; + exports.pointer = pointer; + exports.progress = progress; + exports.wait = wait; + exports.cell = cell; + exports.crosshair = crosshair; + exports.verticalText = verticalText; + exports.alias = alias; + exports.copy = copy; + exports.move = move; + exports.noDrop = noDrop; + exports.notAllowed = notAllowed; + exports.grab = grab; + exports.grabbing = grabbing; + exports.allScroll = allScroll; + exports.colResize = colResize; + exports.rowResize = rowResize; + exports.nResize = nResize; + exports.eResize = eResize; + exports.sResize = sResize; + exports.wResize = wResize; + exports.neResize = neResize; + exports.nwResize = nwResize; + exports.seResize = seResize; + exports.swResize = swResize; + exports.ewResize = ewResize; + exports.nsResize = nsResize; + exports.neswResize = neswResize; + exports.nwseResize = nwseResize; + exports.zoomIn = zoomIn; + exports.zoomOut = zoomOut; + exports.flex3 = flex3; + exports.border = border; + exports.borderTop = borderTop; + exports.backgroundSize = backgroundSize; + exports.textDecoration = textDecoration; + exports.background = background; + exports.backgrounds = backgrounds; + exports.gridAutoColumns = gridAutoColumns; + exports.gridAutoRows = gridAutoRows; + exports.gridTemplateColumns = gridTemplateColumns; + exports.gridTemplateRows = gridTemplateRows; + exports.Calc = Calc; + exports.size = size; + exports.filter = filter; + exports.fontFace = fontFace; + exports.Transition = Transition; + exports.transitionValue = transitionValue; + exports.transitionList = transitionList; + exports.transition = transition; + exports.transitions = transitions; + exports.Animation = Animation; + exports.animationValue = animationValue; + exports.animation = animation; + exports.animations = animations; + exports.animationName = animationName; + exports.SVG = SVG; + exports.touchAction = touchAction; + }); + + // node_modules/@emotion/sheet/dist/emotion-sheet.cjs.dev.js + var require_emotion_sheet_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + function sheetForTag(tag) { + if (tag.sheet) { + return tag.sheet; + } + for (var i = 0; i < document.styleSheets.length; i++) { + if (document.styleSheets[i].ownerNode === tag) { + return document.styleSheets[i]; + } + } + } + function createStyleElement(options) { + var tag = document.createElement("style"); + tag.setAttribute("data-emotion", options.key); + if (options.nonce !== void 0) { + tag.setAttribute("nonce", options.nonce); + } + tag.appendChild(document.createTextNode("")); + tag.setAttribute("data-s", ""); + return tag; + } + var StyleSheet = /* @__PURE__ */ function() { + function StyleSheet2(options) { + var _this = this; + this._insertTag = function(tag) { + var before; + if (_this.tags.length === 0) { + if (_this.insertionPoint) { + before = _this.insertionPoint.nextSibling; + } else if (_this.prepend) { + before = _this.container.firstChild; + } else { + before = _this.before; + } + } else { + before = _this.tags[_this.tags.length - 1].nextSibling; + } + _this.container.insertBefore(tag, before); + _this.tags.push(tag); + }; + this.isSpeedy = options.speedy === void 0 ? false : options.speedy; + this.tags = []; + this.ctr = 0; + this.nonce = options.nonce; + this.key = options.key; + this.container = options.container; + this.prepend = options.prepend; + this.insertionPoint = options.insertionPoint; + this.before = null; + } + var _proto = StyleSheet2.prototype; + _proto.hydrate = function hydrate(nodes) { + nodes.forEach(this._insertTag); + }; + _proto.insert = function insert(rule) { + if (this.ctr % (this.isSpeedy ? 65e3 : 1) === 0) { + this._insertTag(createStyleElement(this)); + } + var tag = this.tags[this.tags.length - 1]; + if (true) { + var isImportRule = rule.charCodeAt(0) === 64 && rule.charCodeAt(1) === 105; + if (isImportRule && this._alreadyInsertedOrderInsensitiveRule) { + console.error("You're attempting to insert the following rule:\n" + rule + "\n\n`@import` rules must be before all other types of rules in a stylesheet but other rules have already been inserted. Please ensure that `@import` rules are before all other rules."); + } + this._alreadyInsertedOrderInsensitiveRule = this._alreadyInsertedOrderInsensitiveRule || !isImportRule; + } + if (this.isSpeedy) { + var sheet = sheetForTag(tag); + try { + sheet.insertRule(rule, sheet.cssRules.length); + } catch (e) { + if (!/:(-moz-placeholder|-moz-focus-inner|-moz-focusring|-ms-input-placeholder|-moz-read-write|-moz-read-only|-ms-clear|-ms-expand|-ms-reveal){/.test(rule)) { + console.error('There was a problem inserting the following rule: "' + rule + '"', e); + } + } + } else { + tag.appendChild(document.createTextNode(rule)); + } + this.ctr++; + }; + _proto.flush = function flush() { + this.tags.forEach(function(tag) { + return tag.parentNode && tag.parentNode.removeChild(tag); + }); + this.tags = []; + this.ctr = 0; + if (true) { + this._alreadyInsertedOrderInsensitiveRule = false; + } + }; + return StyleSheet2; + }(); + exports.StyleSheet = StyleSheet; + }); + + // node_modules/@emotion/sheet/dist/emotion-sheet.cjs.js + var require_emotion_sheet_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_sheet_cjs_dev(); + } + }); + + // node_modules/stylis/dist/umd/stylis.js + var require_stylis = __commonJS((exports, module) => { + (function(e, r) { + typeof exports === "object" && typeof module !== "undefined" ? r(exports) : typeof define === "function" && define.amd ? define(["exports"], r) : (e = e || self, r(e.stylis = {})); + })(exports, function(e) { + "use strict"; + var r = "-ms-"; + var a = "-moz-"; + var c = "-webkit-"; + var t = "comm"; + var n = "rule"; + var s = "decl"; + var i = "@page"; + var u = "@media"; + var o = "@import"; + var f = "@charset"; + var l = "@viewport"; + var p = "@supports"; + var h = "@document"; + var v = "@namespace"; + var d = "@keyframes"; + var b = "@font-face"; + var w = "@counter-style"; + var m = "@font-feature-values"; + var g = Math.abs; + var k = String.fromCharCode; + var $ = Object.assign; + function x(e2, r2) { + return A(e2, 0) ^ 45 ? (((r2 << 2 ^ A(e2, 0)) << 2 ^ A(e2, 1)) << 2 ^ A(e2, 2)) << 2 ^ A(e2, 3) : 0; + } + function E(e2) { + return e2.trim(); + } + function y(e2, r2) { + return (e2 = r2.exec(e2)) ? e2[0] : e2; + } + function T(e2, r2, a2) { + return e2.replace(r2, a2); + } + function O(e2, r2) { + return e2.indexOf(r2); + } + function A(e2, r2) { + return e2.charCodeAt(r2) | 0; + } + function M(e2, r2, a2) { + return e2.slice(r2, a2); + } + function C(e2) { + return e2.length; + } + function S(e2) { + return e2.length; + } + function R(e2, r2) { + return r2.push(e2), e2; + } + function z(e2, r2) { + return e2.map(r2).join(""); + } + e.line = 1; + e.column = 1; + e.length = 0; + e.position = 0; + e.character = 0; + e.characters = ""; + function N(r2, a2, c2, t2, n2, s2, i2) { + return {value: r2, root: a2, parent: c2, type: t2, props: n2, children: s2, line: e.line, column: e.column, length: i2, return: ""}; + } + function P(e2, r2) { + return $(N("", null, null, "", null, null, 0), e2, {length: -e2.length}, r2); + } + function j() { + return e.character; + } + function U() { + e.character = e.position > 0 ? A(e.characters, --e.position) : 0; + if (e.column--, e.character === 10) + e.column = 1, e.line--; + return e.character; + } + function _() { + e.character = e.position < e.length ? A(e.characters, e.position++) : 0; + if (e.column++, e.character === 10) + e.column = 1, e.line++; + return e.character; + } + function F() { + return A(e.characters, e.position); + } + function I() { + return e.position; + } + function L(r2, a2) { + return M(e.characters, r2, a2); + } + function D(e2) { + switch (e2) { + case 0: + case 9: + case 10: + case 13: + case 32: + return 5; + case 33: + case 43: + case 44: + case 47: + case 62: + case 64: + case 126: + case 59: + case 123: + case 125: + return 4; + case 58: + return 3; + case 34: + case 39: + case 40: + case 91: + return 2; + case 41: + case 93: + return 1; + } + return 0; + } + function K(r2) { + return e.line = e.column = 1, e.length = C(e.characters = r2), e.position = 0, []; + } + function V(r2) { + return e.characters = "", r2; + } + function W(r2) { + return E(L(e.position - 1, Z(r2 === 91 ? r2 + 2 : r2 === 40 ? r2 + 1 : r2))); + } + function Y(e2) { + return V(G(K(e2))); + } + function B(r2) { + while (e.character = F()) + if (e.character < 33) + _(); + else + break; + return D(r2) > 2 || D(e.character) > 3 ? "" : " "; + } + function G(r2) { + while (_()) + switch (D(e.character)) { + case 0: + R(J(e.position - 1), r2); + break; + case 2: + R(W(e.character), r2); + break; + default: + R(k(e.character), r2); + } + return r2; + } + function H(r2, a2) { + while (--a2 && _()) + if (e.character < 48 || e.character > 102 || e.character > 57 && e.character < 65 || e.character > 70 && e.character < 97) + break; + return L(r2, I() + (a2 < 6 && F() == 32 && _() == 32)); + } + function Z(r2) { + while (_()) + switch (e.character) { + case r2: + return e.position; + case 34: + case 39: + if (r2 !== 34 && r2 !== 39) + Z(e.character); + break; + case 40: + if (r2 === 41) + Z(r2); + break; + case 92: + _(); + break; + } + return e.position; + } + function q(r2, a2) { + while (_()) + if (r2 + e.character === 47 + 10) + break; + else if (r2 + e.character === 42 + 42 && F() === 47) + break; + return "/*" + L(a2, e.position - 1) + "*" + k(r2 === 47 ? r2 : _()); + } + function J(r2) { + while (!D(F())) + _(); + return L(r2, e.position); + } + function Q(e2) { + return V(X("", null, null, null, [""], e2 = K(e2), 0, [0], e2)); + } + function X(e2, r2, a2, c2, t2, n2, s2, i2, u2) { + var o2 = 0; + var f2 = 0; + var l2 = s2; + var p2 = 0; + var h2 = 0; + var v2 = 0; + var d2 = 1; + var b2 = 1; + var w2 = 1; + var m2 = 0; + var g2 = ""; + var $2 = t2; + var x2 = n2; + var E2 = c2; + var y2 = g2; + while (b2) + switch (v2 = m2, m2 = _()) { + case 40: + if (v2 != 108 && A(y2, l2 - 1) == 58) { + if (O(y2 += T(W(m2), "&", "&\f"), "&\f") != -1) + w2 = -1; + break; + } + case 34: + case 39: + case 91: + y2 += W(m2); + break; + case 9: + case 10: + case 13: + case 32: + y2 += B(v2); + break; + case 92: + y2 += H(I() - 1, 7); + continue; + case 47: + switch (F()) { + case 42: + case 47: + R(re(q(_(), I()), r2, a2), u2); + break; + default: + y2 += "/"; + } + break; + case 123 * d2: + i2[o2++] = C(y2) * w2; + case 125 * d2: + case 59: + case 0: + switch (m2) { + case 0: + case 125: + b2 = 0; + case 59 + f2: + if (h2 > 0 && C(y2) - l2) + R(h2 > 32 ? ae(y2 + ";", c2, a2, l2 - 1) : ae(T(y2, " ", "") + ";", c2, a2, l2 - 2), u2); + break; + case 59: + y2 += ";"; + default: + R(E2 = ee(y2, r2, a2, o2, f2, t2, i2, g2, $2 = [], x2 = [], l2), n2); + if (m2 === 123) + if (f2 === 0) + X(y2, r2, E2, E2, $2, n2, l2, i2, x2); + else + switch (p2 === 99 && A(y2, 3) === 110 ? 100 : p2) { + case 100: + case 109: + case 115: + X(e2, E2, E2, c2 && R(ee(e2, E2, E2, 0, 0, t2, i2, g2, t2, $2 = [], l2), x2), t2, x2, l2, i2, c2 ? $2 : x2); + break; + default: + X(y2, E2, E2, E2, [""], x2, 0, i2, x2); + } + } + o2 = f2 = h2 = 0, d2 = w2 = 1, g2 = y2 = "", l2 = s2; + break; + case 58: + l2 = 1 + C(y2), h2 = v2; + default: + if (d2 < 1) { + if (m2 == 123) + --d2; + else if (m2 == 125 && d2++ == 0 && U() == 125) + continue; + } + switch (y2 += k(m2), m2 * d2) { + case 38: + w2 = f2 > 0 ? 1 : (y2 += "\f", -1); + break; + case 44: + i2[o2++] = (C(y2) - 1) * w2, w2 = 1; + break; + case 64: + if (F() === 45) + y2 += W(_()); + p2 = F(), f2 = l2 = C(g2 = y2 += J(I())), m2++; + break; + case 45: + if (v2 === 45 && C(y2) == 2) + d2 = 0; + } + } + return n2; + } + function ee(e2, r2, a2, c2, t2, s2, i2, u2, o2, f2, l2) { + var p2 = t2 - 1; + var h2 = t2 === 0 ? s2 : [""]; + var v2 = S(h2); + for (var d2 = 0, b2 = 0, w2 = 0; d2 < c2; ++d2) + for (var m2 = 0, k2 = M(e2, p2 + 1, p2 = g(b2 = i2[d2])), $2 = e2; m2 < v2; ++m2) + if ($2 = E(b2 > 0 ? h2[m2] + " " + k2 : T(k2, /&\f/g, h2[m2]))) + o2[w2++] = $2; + return N(e2, r2, a2, t2 === 0 ? n : u2, o2, f2, l2); + } + function re(e2, r2, a2) { + return N(e2, r2, a2, t, k(j()), M(e2, 2, -2), 0); + } + function ae(e2, r2, a2, c2) { + return N(e2, r2, a2, s, M(e2, 0, c2), M(e2, c2 + 1, -1), c2); + } + function ce(e2, t2, n2) { + switch (x(e2, t2)) { + case 5103: + return c + "print-" + e2 + e2; + case 5737: + case 4201: + case 3177: + case 3433: + case 1641: + case 4457: + case 2921: + case 5572: + case 6356: + case 5844: + case 3191: + case 6645: + case 3005: + case 6391: + case 5879: + case 5623: + case 6135: + case 4599: + case 4855: + case 4215: + case 6389: + case 5109: + case 5365: + case 5621: + case 3829: + return c + e2 + e2; + case 4789: + return a + e2 + e2; + case 5349: + case 4246: + case 4810: + case 6968: + case 2756: + return c + e2 + a + e2 + r + e2 + e2; + case 5936: + switch (A(e2, t2 + 11)) { + case 114: + return c + e2 + r + T(e2, /[svh]\w+-[tblr]{2}/, "tb") + e2; + case 108: + return c + e2 + r + T(e2, /[svh]\w+-[tblr]{2}/, "tb-rl") + e2; + case 45: + return c + e2 + r + T(e2, /[svh]\w+-[tblr]{2}/, "lr") + e2; + } + case 6828: + case 4268: + case 2903: + return c + e2 + r + e2 + e2; + case 6165: + return c + e2 + r + "flex-" + e2 + e2; + case 5187: + return c + e2 + T(e2, /(\w+).+(:[^]+)/, c + "box-$1$2" + r + "flex-$1$2") + e2; + case 5443: + return c + e2 + r + "flex-item-" + T(e2, /flex-|-self/g, "") + (!y(e2, /flex-|baseline/) ? r + "grid-row-" + T(e2, /flex-|-self/g, "") : "") + e2; + case 4675: + return c + e2 + r + "flex-line-pack" + T(e2, /align-content|flex-|-self/g, "") + e2; + case 5548: + return c + e2 + r + T(e2, "shrink", "negative") + e2; + case 5292: + return c + e2 + r + T(e2, "basis", "preferred-size") + e2; + case 6060: + return c + "box-" + T(e2, "-grow", "") + c + e2 + r + T(e2, "grow", "positive") + e2; + case 4554: + return c + T(e2, /([^-])(transform)/g, "$1" + c + "$2") + e2; + case 6187: + return T(T(T(e2, /(zoom-|grab)/, c + "$1"), /(image-set)/, c + "$1"), e2, "") + e2; + case 5495: + case 3959: + return T(e2, /(image-set\([^]*)/, c + "$1$`$1"); + case 4968: + return T(T(e2, /(.+:)(flex-)?(.*)/, c + "box-pack:$3" + r + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + c + e2 + e2; + case 4200: + if (!y(e2, /flex-|baseline/)) + return r + "grid-column-align" + M(e2, t2) + e2; + break; + case 2592: + case 3360: + return r + T(e2, "template-", "") + e2; + case 4384: + case 3616: + if (n2 && n2.some(function(e3, r2) { + return t2 = r2, y(e3.props, /grid-\w+-end/); + })) { + return ~O(e2 + (n2 = n2[t2].value), "span") ? e2 : r + T(e2, "-start", "") + e2 + r + "grid-row-span:" + (~O(n2, "span") ? y(n2, /\d+/) : +y(n2, /\d+/) - +y(e2, /\d+/)) + ";"; + } + return r + T(e2, "-start", "") + e2; + case 4896: + case 4128: + return n2 && n2.some(function(e3) { + return y(e3.props, /grid-\w+-start/); + }) ? e2 : r + T(T(e2, "-end", "-span"), "span ", "") + e2; + case 4095: + case 3583: + case 4068: + case 2532: + return T(e2, /(.+)-inline(.+)/, c + "$1$2") + e2; + case 8116: + case 7059: + case 5753: + case 5535: + case 5445: + case 5701: + case 4933: + case 4677: + case 5533: + case 5789: + case 5021: + case 4765: + if (C(e2) - 1 - t2 > 6) + switch (A(e2, t2 + 1)) { + case 109: + if (A(e2, t2 + 4) !== 45) + break; + case 102: + return T(e2, /(.+:)(.+)-([^]+)/, "$1" + c + "$2-$3$1" + a + (A(e2, t2 + 3) == 108 ? "$3" : "$2-$3")) + e2; + case 115: + return ~O(e2, "stretch") ? ce(T(e2, "stretch", "fill-available"), t2, n2) + e2 : e2; + } + break; + case 5152: + case 5920: + return T(e2, /(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/, function(a2, c2, t3, n3, s2, i2, u2) { + return r + c2 + ":" + t3 + u2 + (n3 ? r + c2 + "-span:" + (s2 ? i2 : +i2 - +t3) + u2 : "") + e2; + }); + case 4949: + if (A(e2, t2 + 6) === 121) + return T(e2, ":", ":" + c) + e2; + break; + case 6444: + switch (A(e2, A(e2, 14) === 45 ? 18 : 11)) { + case 120: + return T(e2, /(.+:)([^;\s!]+)(;|(\s+)?!.+)?/, "$1" + c + (A(e2, 14) === 45 ? "inline-" : "") + "box$3$1" + c + "$2$3$1" + r + "$2box$3") + e2; + case 100: + return T(e2, ":", ":" + r) + e2; + } + break; + case 5719: + case 2647: + case 2135: + case 3927: + case 2391: + return T(e2, "scroll-", "scroll-snap-") + e2; + } + return e2; + } + function te(e2, r2) { + var a2 = ""; + var c2 = S(e2); + for (var t2 = 0; t2 < c2; t2++) + a2 += r2(e2[t2], t2, e2, r2) || ""; + return a2; + } + function ne(e2, r2, a2, c2) { + switch (e2.type) { + case o: + case s: + return e2.return = e2.return || e2.value; + case t: + return ""; + case d: + return e2.return = e2.value + "{" + te(e2.children, c2) + "}"; + case n: + e2.value = e2.props.join(","); + } + return C(a2 = te(e2.children, c2)) ? e2.return = e2.value + "{" + a2 + "}" : ""; + } + function se(e2) { + var r2 = S(e2); + return function(a2, c2, t2, n2) { + var s2 = ""; + for (var i2 = 0; i2 < r2; i2++) + s2 += e2[i2](a2, c2, t2, n2) || ""; + return s2; + }; + } + function ie(e2) { + return function(r2) { + if (!r2.root) { + if (r2 = r2.return) + e2(r2); + } + }; + } + function ue(e2, t2, i2, u2) { + if (e2.length > -1) { + if (!e2.return) + switch (e2.type) { + case s: + e2.return = ce(e2.value, e2.length, i2); + return; + case d: + return te([P(e2, {value: T(e2.value, "@", "@" + c)})], u2); + case n: + if (e2.length) + return z(e2.props, function(t3) { + switch (y(t3, /(::plac\w+|:read-\w+)/)) { + case ":read-only": + case ":read-write": + return te([P(e2, {props: [T(t3, /:(read-\w+)/, ":" + a + "$1")]})], u2); + case "::placeholder": + return te([P(e2, {props: [T(t3, /:(plac\w+)/, ":" + c + "input-$1")]}), P(e2, {props: [T(t3, /:(plac\w+)/, ":" + a + "$1")]}), P(e2, {props: [T(t3, /:(plac\w+)/, r + "input-$1")]})], u2); + } + return ""; + }); + } + } + } + function oe(e2) { + switch (e2.type) { + case n: + e2.props = e2.props.map(function(r2) { + return z(Y(r2), function(r3, a2, c2) { + switch (A(r3, 0)) { + case 12: + return M(r3, 1, C(r3)); + case 0: + case 40: + case 43: + case 62: + case 126: + return r3; + case 58: + if (c2[++a2] === "global") + c2[a2] = "", c2[++a2] = "\f" + M(c2[a2], a2 = 1, -1); + case 32: + return a2 === 1 ? "" : r3; + default: + switch (a2) { + case 0: + e2 = r3; + return S(c2) > 1 ? "" : r3; + case (a2 = S(c2) - 1): + case 2: + return a2 === 2 ? r3 + e2 + e2 : r3 + e2; + default: + return r3; + } + } + }); + }); + } + } + e.CHARSET = f; + e.COMMENT = t; + e.COUNTER_STYLE = w; + e.DECLARATION = s; + e.DOCUMENT = h; + e.FONT_FACE = b; + e.FONT_FEATURE_VALUES = m; + e.IMPORT = o; + e.KEYFRAMES = d; + e.MEDIA = u; + e.MOZ = a; + e.MS = r; + e.NAMESPACE = v; + e.PAGE = i; + e.RULESET = n; + e.SUPPORTS = p; + e.VIEWPORT = l; + e.WEBKIT = c; + e.abs = g; + e.alloc = K; + e.append = R; + e.assign = $; + e.caret = I; + e.char = j; + e.charat = A; + e.combine = z; + e.comment = re; + e.commenter = q; + e.compile = Q; + e.copy = P; + e.dealloc = V; + e.declaration = ae; + e.delimit = W; + e.delimiter = Z; + e.escaping = H; + e.from = k; + e.hash = x; + e.identifier = J; + e.indexof = O; + e.match = y; + e.middleware = se; + e.namespace = oe; + e.next = _; + e.node = N; + e.parse = X; + e.peek = F; + e.prefix = ce; + e.prefixer = ue; + e.prev = U; + e.replace = T; + e.ruleset = ee; + e.rulesheet = ie; + e.serialize = te; + e.sizeof = S; + e.slice = L; + e.stringify = ne; + e.strlen = C; + e.substr = M; + e.token = D; + e.tokenize = Y; + e.tokenizer = G; + e.trim = E; + e.whitespace = B; + Object.defineProperty(e, "__esModule", {value: true}); + }); + }); + + // node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.cjs.dev.js + var require_emotion_weak_memoize_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var weakMemoize = function weakMemoize2(func) { + var cache = new WeakMap(); + return function(arg) { + if (cache.has(arg)) { + return cache.get(arg); + } + var ret = func(arg); + cache.set(arg, ret); + return ret; + }; + }; + exports.default = weakMemoize; + }); + + // node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.cjs.js + var require_emotion_weak_memoize_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_weak_memoize_cjs_dev(); + } + }); + + // node_modules/@emotion/memoize/dist/emotion-memoize.cjs.dev.js + var require_emotion_memoize_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + function memoize(fn) { + var cache = Object.create(null); + return function(arg) { + if (cache[arg] === void 0) + cache[arg] = fn(arg); + return cache[arg]; + }; + } + exports.default = memoize; + }); + + // node_modules/@emotion/memoize/dist/emotion-memoize.cjs.js + var require_emotion_memoize_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_memoize_cjs_dev(); + } + }); + + // node_modules/@emotion/cache/dist/emotion-cache.cjs.dev.js + var require_emotion_cache_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var sheet = require_emotion_sheet_cjs(); + var stylis = require_stylis(); + var weakMemoize = require_emotion_weak_memoize_cjs(); + var memoize = require_emotion_memoize_cjs(); + function _interopDefault(e) { + return e && e.__esModule ? e : {default: e}; + } + var weakMemoize__default = /* @__PURE__ */ _interopDefault(weakMemoize); + var memoize__default = /* @__PURE__ */ _interopDefault(memoize); + var identifierWithPointTracking = function identifierWithPointTracking2(begin, points, index) { + var previous = 0; + var character = 0; + while (true) { + previous = character; + character = stylis.peek(); + if (previous === 38 && character === 12) { + points[index] = 1; + } + if (stylis.token(character)) { + break; + } + stylis.next(); + } + return stylis.slice(begin, stylis.position); + }; + var toRules = function toRules2(parsed, points) { + var index = -1; + var character = 44; + do { + switch (stylis.token(character)) { + case 0: + if (character === 38 && stylis.peek() === 12) { + points[index] = 1; + } + parsed[index] += identifierWithPointTracking(stylis.position - 1, points, index); + break; + case 2: + parsed[index] += stylis.delimit(character); + break; + case 4: + if (character === 44) { + parsed[++index] = stylis.peek() === 58 ? "&\f" : ""; + points[index] = parsed[index].length; + break; + } + default: + parsed[index] += stylis.from(character); + } + } while (character = stylis.next()); + return parsed; + }; + var getRules = function getRules2(value, points) { + return stylis.dealloc(toRules(stylis.alloc(value), points)); + }; + var fixedElements = /* @__PURE__ */ new WeakMap(); + var compat = function compat2(element) { + if (element.type !== "rule" || !element.parent || element.length < 1) { + return; + } + var value = element.value, parent = element.parent; + var isImplicitRule = element.column === parent.column && element.line === parent.line; + while (parent.type !== "rule") { + parent = parent.parent; + if (!parent) + return; + } + if (element.props.length === 1 && value.charCodeAt(0) !== 58 && !fixedElements.get(parent)) { + return; + } + if (isImplicitRule) { + return; + } + fixedElements.set(element, true); + var points = []; + var rules = getRules(value, points); + var parentRules = parent.props; + for (var i = 0, k = 0; i < rules.length; i++) { + for (var j = 0; j < parentRules.length; j++, k++) { + element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i]; + } + } + }; + var removeLabel = function removeLabel2(element) { + if (element.type === "decl") { + var value = element.value; + if (value.charCodeAt(0) === 108 && value.charCodeAt(2) === 98) { + element["return"] = ""; + element.value = ""; + } + } + }; + var ignoreFlag = "emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason"; + var isIgnoringComment = function isIgnoringComment2(element) { + return element.type === "comm" && element.children.indexOf(ignoreFlag) > -1; + }; + var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm2(cache) { + return function(element, index, children) { + if (element.type !== "rule" || cache.compat) + return; + var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g); + if (unsafePseudoClasses) { + var isNested = element.parent === children[0]; + var commentContainer = isNested ? children[0].children : children; + for (var i = commentContainer.length - 1; i >= 0; i--) { + var node = commentContainer[i]; + if (node.line < element.line) { + break; + } + if (node.column < element.column) { + if (isIgnoringComment(node)) { + return; + } + break; + } + } + unsafePseudoClasses.forEach(function(unsafePseudoClass) { + console.error('The pseudo class "' + unsafePseudoClass + '" is potentially unsafe when doing server-side rendering. Try changing it to "' + unsafePseudoClass.split("-child")[0] + '-of-type".'); + }); + } + }; + }; + var isImportRule = function isImportRule2(element) { + return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64; + }; + var isPrependedWithRegularRules = function isPrependedWithRegularRules2(index, children) { + for (var i = index - 1; i >= 0; i--) { + if (!isImportRule(children[i])) { + return true; + } + } + return false; + }; + var nullifyElement = function nullifyElement2(element) { + element.type = ""; + element.value = ""; + element["return"] = ""; + element.children = ""; + element.props = ""; + }; + var incorrectImportAlarm = function incorrectImportAlarm2(element, index, children) { + if (!isImportRule(element)) { + return; + } + if (element.parent) { + console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles."); + nullifyElement(element); + } else if (isPrependedWithRegularRules(index, children)) { + console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules."); + nullifyElement(element); + } + }; + function prefix(value, length) { + switch (stylis.hash(value, length)) { + case 5103: + return stylis.WEBKIT + "print-" + value + value; + case 5737: + case 4201: + case 3177: + case 3433: + case 1641: + case 4457: + case 2921: + case 5572: + case 6356: + case 5844: + case 3191: + case 6645: + case 3005: + case 6391: + case 5879: + case 5623: + case 6135: + case 4599: + case 4855: + case 4215: + case 6389: + case 5109: + case 5365: + case 5621: + case 3829: + return stylis.WEBKIT + value + value; + case 5349: + case 4246: + case 4810: + case 6968: + case 2756: + return stylis.WEBKIT + value + stylis.MOZ + value + stylis.MS + value + value; + case 6828: + case 4268: + return stylis.WEBKIT + value + stylis.MS + value + value; + case 6165: + return stylis.WEBKIT + value + stylis.MS + "flex-" + value + value; + case 5187: + return stylis.WEBKIT + value + stylis.replace(value, /(\w+).+(:[^]+)/, stylis.WEBKIT + "box-$1$2" + stylis.MS + "flex-$1$2") + value; + case 5443: + return stylis.WEBKIT + value + stylis.MS + "flex-item-" + stylis.replace(value, /flex-|-self/, "") + value; + case 4675: + return stylis.WEBKIT + value + stylis.MS + "flex-line-pack" + stylis.replace(value, /align-content|flex-|-self/, "") + value; + case 5548: + return stylis.WEBKIT + value + stylis.MS + stylis.replace(value, "shrink", "negative") + value; + case 5292: + return stylis.WEBKIT + value + stylis.MS + stylis.replace(value, "basis", "preferred-size") + value; + case 6060: + return stylis.WEBKIT + "box-" + stylis.replace(value, "-grow", "") + stylis.WEBKIT + value + stylis.MS + stylis.replace(value, "grow", "positive") + value; + case 4554: + return stylis.WEBKIT + stylis.replace(value, /([^-])(transform)/g, "$1" + stylis.WEBKIT + "$2") + value; + case 6187: + return stylis.replace(stylis.replace(stylis.replace(value, /(zoom-|grab)/, stylis.WEBKIT + "$1"), /(image-set)/, stylis.WEBKIT + "$1"), value, "") + value; + case 5495: + case 3959: + return stylis.replace(value, /(image-set\([^]*)/, stylis.WEBKIT + "$1$`$1"); + case 4968: + return stylis.replace(stylis.replace(value, /(.+:)(flex-)?(.*)/, stylis.WEBKIT + "box-pack:$3" + stylis.MS + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + stylis.WEBKIT + value + value; + case 4095: + case 3583: + case 4068: + case 2532: + return stylis.replace(value, /(.+)-inline(.+)/, stylis.WEBKIT + "$1$2") + value; + case 8116: + case 7059: + case 5753: + case 5535: + case 5445: + case 5701: + case 4933: + case 4677: + case 5533: + case 5789: + case 5021: + case 4765: + if (stylis.strlen(value) - 1 - length > 6) + switch (stylis.charat(value, length + 1)) { + case 109: + if (stylis.charat(value, length + 4) !== 45) + break; + case 102: + return stylis.replace(value, /(.+:)(.+)-([^]+)/, "$1" + stylis.WEBKIT + "$2-$3$1" + stylis.MOZ + (stylis.charat(value, length + 3) == 108 ? "$3" : "$2-$3")) + value; + case 115: + return ~stylis.indexof(value, "stretch") ? prefix(stylis.replace(value, "stretch", "fill-available"), length) + value : value; + } + break; + case 4949: + if (stylis.charat(value, length + 1) !== 115) + break; + case 6444: + switch (stylis.charat(value, stylis.strlen(value) - 3 - (~stylis.indexof(value, "!important") && 10))) { + case 107: + return stylis.replace(value, ":", ":" + stylis.WEBKIT) + value; + case 101: + return stylis.replace(value, /(.+:)([^;!]+)(;|!.+)?/, "$1" + stylis.WEBKIT + (stylis.charat(value, 14) === 45 ? "inline-" : "") + "box$3$1" + stylis.WEBKIT + "$2$3$1" + stylis.MS + "$2box$3") + value; + } + break; + case 5936: + switch (stylis.charat(value, length + 11)) { + case 114: + return stylis.WEBKIT + value + stylis.MS + stylis.replace(value, /[svh]\w+-[tblr]{2}/, "tb") + value; + case 108: + return stylis.WEBKIT + value + stylis.MS + stylis.replace(value, /[svh]\w+-[tblr]{2}/, "tb-rl") + value; + case 45: + return stylis.WEBKIT + value + stylis.MS + stylis.replace(value, /[svh]\w+-[tblr]{2}/, "lr") + value; + } + return stylis.WEBKIT + value + stylis.MS + value + value; + } + return value; + } + var prefixer = function prefixer2(element, index, children, callback) { + if (element.length > -1) { + if (!element["return"]) + switch (element.type) { + case stylis.DECLARATION: + element["return"] = prefix(element.value, element.length); + break; + case stylis.KEYFRAMES: + return stylis.serialize([stylis.copy(element, { + value: stylis.replace(element.value, "@", "@" + stylis.WEBKIT) + })], callback); + case stylis.RULESET: + if (element.length) + return stylis.combine(element.props, function(value) { + switch (stylis.match(value, /(::plac\w+|:read-\w+)/)) { + case ":read-only": + case ":read-write": + return stylis.serialize([stylis.copy(element, { + props: [stylis.replace(value, /:(read-\w+)/, ":" + stylis.MOZ + "$1")] + })], callback); + case "::placeholder": + return stylis.serialize([stylis.copy(element, { + props: [stylis.replace(value, /:(plac\w+)/, ":" + stylis.WEBKIT + "input-$1")] + }), stylis.copy(element, { + props: [stylis.replace(value, /:(plac\w+)/, ":" + stylis.MOZ + "$1")] + }), stylis.copy(element, { + props: [stylis.replace(value, /:(plac\w+)/, stylis.MS + "input-$1")] + })], callback); + } + return ""; + }); + } + } + }; + var isBrowser = typeof document !== "undefined"; + var getServerStylisCache = isBrowser ? void 0 : weakMemoize__default["default"](function() { + return memoize__default["default"](function() { + var cache = {}; + return function(name) { + return cache[name]; + }; + }); + }); + var defaultStylisPlugins = [prefixer]; + var createCache = function createCache2(options) { + var key = options.key; + if (!key) { + throw new Error("You have to configure `key` for your cache. Please make sure it's unique (and not equal to 'css') as it's used for linking styles to your cache.\nIf multiple caches share the same key they might \"fight\" for each other's style elements."); + } + if (isBrowser && key === "css") { + var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); + Array.prototype.forEach.call(ssrStyles, function(node) { + var dataEmotionAttribute = node.getAttribute("data-emotion"); + if (dataEmotionAttribute.indexOf(" ") === -1) { + return; + } + document.head.appendChild(node); + node.setAttribute("data-s", ""); + }); + } + var stylisPlugins = options.stylisPlugins || defaultStylisPlugins; + if (true) { + if (/[^a-z-]/.test(key)) { + throw new Error('Emotion key must only contain lower case alphabetical characters and - but "' + key + '" was passed'); + } + } + var inserted = {}; + var container; + var nodesToHydrate = []; + if (isBrowser) { + container = options.container || document.head; + Array.prototype.forEach.call(document.querySelectorAll('style[data-emotion^="' + key + ' "]'), function(node) { + var attrib = node.getAttribute("data-emotion").split(" "); + for (var i = 1; i < attrib.length; i++) { + inserted[attrib[i]] = true; + } + nodesToHydrate.push(node); + }); + } + var _insert; + var omnipresentPlugins = [compat, removeLabel]; + if (true) { + omnipresentPlugins.push(createUnsafeSelectorsAlarm({ + get compat() { + return cache.compat; + } + }), incorrectImportAlarm); + } + if (isBrowser) { + var currentSheet; + var finalizingPlugins = [stylis.stringify, true ? function(element) { + if (!element.root) { + if (element["return"]) { + currentSheet.insert(element["return"]); + } else if (element.value && element.type !== stylis.COMMENT) { + currentSheet.insert(element.value + "{}"); + } + } + } : stylis.rulesheet(function(rule) { + currentSheet.insert(rule); + })]; + var serializer = stylis.middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins)); + var stylis$1 = function stylis$12(styles) { + return stylis.serialize(stylis.compile(styles), serializer); + }; + _insert = function insert(selector, serialized, sheet2, shouldCache) { + currentSheet = sheet2; + if (serialized.map !== void 0) { + currentSheet = { + insert: function insert2(rule) { + sheet2.insert(rule + serialized.map); + } + }; + } + stylis$1(selector ? selector + "{" + serialized.styles + "}" : serialized.styles); + if (shouldCache) { + cache.inserted[serialized.name] = true; + } + }; + } else { + var _finalizingPlugins = [stylis.stringify]; + var _serializer = stylis.middleware(omnipresentPlugins.concat(stylisPlugins, _finalizingPlugins)); + var _stylis = function _stylis2(styles) { + return stylis.serialize(stylis.compile(styles), _serializer); + }; + var serverStylisCache = getServerStylisCache(stylisPlugins)(key); + var getRules2 = function getRules3(selector, serialized) { + var name = serialized.name; + if (serverStylisCache[name] === void 0) { + serverStylisCache[name] = _stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles); + } + return serverStylisCache[name]; + }; + _insert = function _insert2(selector, serialized, sheet2, shouldCache) { + var name = serialized.name; + var rules = getRules2(selector, serialized); + if (cache.compat === void 0) { + if (shouldCache) { + cache.inserted[name] = true; + } + if (serialized.map !== void 0) { + return rules + serialized.map; + } + return rules; + } else { + if (shouldCache) { + cache.inserted[name] = rules; + } else { + return rules; + } + } + }; + } + var cache = { + key, + sheet: new sheet.StyleSheet({ + key, + container, + nonce: options.nonce, + speedy: options.speedy, + prepend: options.prepend, + insertionPoint: options.insertionPoint + }), + nonce: options.nonce, + inserted, + registered: {}, + insert: _insert + }; + cache.sheet.hydrate(nodesToHydrate); + return cache; + }; + exports.default = createCache; + }); + + // node_modules/@emotion/cache/dist/emotion-cache.cjs.js + var require_emotion_cache_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_cache_cjs_dev(); + } + }); + + // node_modules/@emotion/hash/dist/emotion-hash.cjs.dev.js + var require_emotion_hash_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + function murmur2(str) { + var h = 0; + var k, i = 0, len = str.length; + for (; len >= 4; ++i, len -= 4) { + k = str.charCodeAt(i) & 255 | (str.charCodeAt(++i) & 255) << 8 | (str.charCodeAt(++i) & 255) << 16 | (str.charCodeAt(++i) & 255) << 24; + k = (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16); + k ^= k >>> 24; + h = (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16) ^ (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16); + } + switch (len) { + case 3: + h ^= (str.charCodeAt(i + 2) & 255) << 16; + case 2: + h ^= (str.charCodeAt(i + 1) & 255) << 8; + case 1: + h ^= str.charCodeAt(i) & 255; + h = (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16); + } + h ^= h >>> 13; + h = (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16); + return ((h ^ h >>> 15) >>> 0).toString(36); + } + exports.default = murmur2; + }); + + // node_modules/@emotion/hash/dist/emotion-hash.cjs.js + var require_emotion_hash_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_hash_cjs_dev(); + } + }); + + // node_modules/@emotion/unitless/dist/emotion-unitless.cjs.dev.js + var require_emotion_unitless_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var unitlessKeys = { + animationIterationCount: 1, + borderImageOutset: 1, + borderImageSlice: 1, + borderImageWidth: 1, + boxFlex: 1, + boxFlexGroup: 1, + boxOrdinalGroup: 1, + columnCount: 1, + columns: 1, + flex: 1, + flexGrow: 1, + flexPositive: 1, + flexShrink: 1, + flexNegative: 1, + flexOrder: 1, + gridRow: 1, + gridRowEnd: 1, + gridRowSpan: 1, + gridRowStart: 1, + gridColumn: 1, + gridColumnEnd: 1, + gridColumnSpan: 1, + gridColumnStart: 1, + msGridRow: 1, + msGridRowSpan: 1, + msGridColumn: 1, + msGridColumnSpan: 1, + fontWeight: 1, + lineHeight: 1, + opacity: 1, + order: 1, + orphans: 1, + tabSize: 1, + widows: 1, + zIndex: 1, + zoom: 1, + WebkitLineClamp: 1, + fillOpacity: 1, + floodOpacity: 1, + stopOpacity: 1, + strokeDasharray: 1, + strokeDashoffset: 1, + strokeMiterlimit: 1, + strokeOpacity: 1, + strokeWidth: 1 + }; + exports.default = unitlessKeys; + }); + + // node_modules/@emotion/unitless/dist/emotion-unitless.cjs.js + var require_emotion_unitless_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_unitless_cjs_dev(); + } + }); + + // node_modules/@emotion/serialize/dist/emotion-serialize.cjs.dev.js + var require_emotion_serialize_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var hashString = require_emotion_hash_cjs(); + var unitless = require_emotion_unitless_cjs(); + var memoize = require_emotion_memoize_cjs(); + function _interopDefault(e) { + return e && e.__esModule ? e : {default: e}; + } + var hashString__default = /* @__PURE__ */ _interopDefault(hashString); + var unitless__default = /* @__PURE__ */ _interopDefault(unitless); + var memoize__default = /* @__PURE__ */ _interopDefault(memoize); + var ILLEGAL_ESCAPE_SEQUENCE_ERROR = `You have illegal escape sequence in your template literal, most likely inside content's property value. +Because you write your CSS inside a JavaScript string you actually have to do double escaping, so for example "content: '\\00d7';" should become "content: '\\\\00d7';". +You can read more about this here: +https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences`; + var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key)."; + var hyphenateRegex = /[A-Z]|^ms/g; + var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g; + var isCustomProperty = function isCustomProperty2(property) { + return property.charCodeAt(1) === 45; + }; + var isProcessableValue = function isProcessableValue2(value) { + return value != null && typeof value !== "boolean"; + }; + var processStyleName = /* @__PURE__ */ memoize__default["default"](function(styleName) { + return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, "-$&").toLowerCase(); + }); + var processStyleValue = function processStyleValue2(key, value) { + switch (key) { + case "animation": + case "animationName": { + if (typeof value === "string") { + return value.replace(animationRegex, function(match, p1, p2) { + cursor = { + name: p1, + styles: p2, + next: cursor + }; + return p1; + }); + } + } + } + if (unitless__default["default"][key] !== 1 && !isCustomProperty(key) && typeof value === "number" && value !== 0) { + return value + "px"; + } + return value; + }; + if (true) { + contentValuePattern = /(var|attr|counters?|url|element|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/; + contentValues = ["normal", "none", "initial", "inherit", "unset"]; + oldProcessStyleValue = processStyleValue; + msPattern = /^-ms-/; + hyphenPattern = /-(.)/g; + hyphenatedCache = {}; + processStyleValue = function processStyleValue2(key, value) { + if (key === "content") { + if (typeof value !== "string" || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '"' && value.charAt(0) !== "'")) { + throw new Error("You seem to be using a value for 'content' without quotes, try replacing it with `content: '\"" + value + "\"'`"); + } + } + var processed = oldProcessStyleValue(key, value); + if (processed !== "" && !isCustomProperty(key) && key.indexOf("-") !== -1 && hyphenatedCache[key] === void 0) { + hyphenatedCache[key] = true; + console.error("Using kebab-case for css properties in objects is not supported. Did you mean " + key.replace(msPattern, "ms-").replace(hyphenPattern, function(str, _char) { + return _char.toUpperCase(); + }) + "?"); + } + return processed; + }; + } + var contentValuePattern; + var contentValues; + var oldProcessStyleValue; + var msPattern; + var hyphenPattern; + var hyphenatedCache; + var noComponentSelectorMessage = "Component selectors can only be used in conjunction with @emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware compiler transform."; + function handleInterpolation(mergedProps, registered, interpolation) { + if (interpolation == null) { + return ""; + } + if (interpolation.__emotion_styles !== void 0) { + if (interpolation.toString() === "NO_COMPONENT_SELECTOR") { + throw new Error(noComponentSelectorMessage); + } + return interpolation; + } + switch (typeof interpolation) { + case "boolean": { + return ""; + } + case "object": { + if (interpolation.anim === 1) { + cursor = { + name: interpolation.name, + styles: interpolation.styles, + next: cursor + }; + return interpolation.name; + } + if (interpolation.styles !== void 0) { + var next = interpolation.next; + if (next !== void 0) { + while (next !== void 0) { + cursor = { + name: next.name, + styles: next.styles, + next: cursor + }; + next = next.next; + } + } + var styles = interpolation.styles + ";"; + if (interpolation.map !== void 0) { + styles += interpolation.map; + } + return styles; + } + return createStringFromObject(mergedProps, registered, interpolation); + } + case "function": { + if (mergedProps !== void 0) { + var previousCursor = cursor; + var result = interpolation(mergedProps); + cursor = previousCursor; + return handleInterpolation(mergedProps, registered, result); + } else if (true) { + console.error("Functions that are interpolated in css calls will be stringified.\nIf you want to have a css call based on props, create a function that returns a css call like this\nlet dynamicStyle = (props) => css`color: ${props.color}`\nIt can be called directly with props or interpolated in a styled call like this\nlet SomeComponent = styled('div')`${dynamicStyle}`"); + } + break; + } + case "string": + if (true) { + var matched = []; + var replaced = interpolation.replace(animationRegex, function(match, p1, p2) { + var fakeVarName = "animation" + matched.length; + matched.push("const " + fakeVarName + " = keyframes`" + p2.replace(/^@keyframes animation-\w+/, "") + "`"); + return "${" + fakeVarName + "}"; + }); + if (matched.length) { + console.error("`keyframes` output got interpolated into plain string, please wrap it with `css`.\n\nInstead of doing this:\n\n" + [].concat(matched, ["`" + replaced + "`"]).join("\n") + "\n\nYou should wrap it with `css` like this:\n\n" + ("css`" + replaced + "`")); + } + } + break; + } + if (registered == null) { + return interpolation; + } + var cached = registered[interpolation]; + return cached !== void 0 ? cached : interpolation; + } + function createStringFromObject(mergedProps, registered, obj) { + var string = ""; + if (Array.isArray(obj)) { + for (var i = 0; i < obj.length; i++) { + string += handleInterpolation(mergedProps, registered, obj[i]) + ";"; + } + } else { + for (var _key in obj) { + var value = obj[_key]; + if (typeof value !== "object") { + if (registered != null && registered[value] !== void 0) { + string += _key + "{" + registered[value] + "}"; + } else if (isProcessableValue(value)) { + string += processStyleName(_key) + ":" + processStyleValue(_key, value) + ";"; + } + } else { + if (_key === "NO_COMPONENT_SELECTOR" && true) { + throw new Error(noComponentSelectorMessage); + } + if (Array.isArray(value) && typeof value[0] === "string" && (registered == null || registered[value[0]] === void 0)) { + for (var _i = 0; _i < value.length; _i++) { + if (isProcessableValue(value[_i])) { + string += processStyleName(_key) + ":" + processStyleValue(_key, value[_i]) + ";"; + } + } + } else { + var interpolated = handleInterpolation(mergedProps, registered, value); + switch (_key) { + case "animation": + case "animationName": { + string += processStyleName(_key) + ":" + interpolated + ";"; + break; + } + default: { + if (_key === "undefined") { + console.error(UNDEFINED_AS_OBJECT_KEY_ERROR); + } + string += _key + "{" + interpolated + "}"; + } + } + } + } + } + } + return string; + } + var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g; + var sourceMapPattern; + if (true) { + sourceMapPattern = /\/\*#\ssourceMappingURL=data:application\/json;\S+\s+\*\//g; + } + var cursor; + var serializeStyles = function serializeStyles2(args, registered, mergedProps) { + if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && args[0].styles !== void 0) { + return args[0]; + } + var stringMode = true; + var styles = ""; + cursor = void 0; + var strings = args[0]; + if (strings == null || strings.raw === void 0) { + stringMode = false; + styles += handleInterpolation(mergedProps, registered, strings); + } else { + if (strings[0] === void 0) { + console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR); + } + styles += strings[0]; + } + for (var i = 1; i < args.length; i++) { + styles += handleInterpolation(mergedProps, registered, args[i]); + if (stringMode) { + if (strings[i] === void 0) { + console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR); + } + styles += strings[i]; + } + } + var sourceMap; + if (true) { + styles = styles.replace(sourceMapPattern, function(match2) { + sourceMap = match2; + return ""; + }); + } + labelPattern.lastIndex = 0; + var identifierName = ""; + var match; + while ((match = labelPattern.exec(styles)) !== null) { + identifierName += "-" + match[1]; + } + var name = hashString__default["default"](styles) + identifierName; + if (true) { + return { + name, + styles, + map: sourceMap, + next: cursor, + toString: function toString() { + return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; + } + }; + } + return { + name, + styles, + next: cursor + }; + }; + exports.serializeStyles = serializeStyles; + }); + + // node_modules/@emotion/serialize/dist/emotion-serialize.cjs.js + var require_emotion_serialize_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_serialize_cjs_dev(); + } + }); + + // node_modules/@emotion/utils/dist/emotion-utils.cjs.dev.js + var require_emotion_utils_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var isBrowser = typeof document !== "undefined"; + function getRegisteredStyles(registered, registeredStyles, classNames) { + var rawClassName = ""; + classNames.split(" ").forEach(function(className) { + if (registered[className] !== void 0) { + registeredStyles.push(registered[className] + ";"); + } else { + rawClassName += className + " "; + } + }); + return rawClassName; + } + var registerStyles = function registerStyles2(cache, serialized, isStringTag) { + var className = cache.key + "-" + serialized.name; + if ((isStringTag === false || isBrowser === false && cache.compat !== void 0) && cache.registered[className] === void 0) { + cache.registered[className] = serialized.styles; + } + }; + var insertStyles = function insertStyles2(cache, serialized, isStringTag) { + registerStyles(cache, serialized, isStringTag); + var className = cache.key + "-" + serialized.name; + if (cache.inserted[serialized.name] === void 0) { + var stylesForSSR = ""; + var current = serialized; + do { + var maybeStyles = cache.insert(serialized === current ? "." + className : "", current, cache.sheet, true); + if (!isBrowser && maybeStyles !== void 0) { + stylesForSSR += maybeStyles; + } + current = current.next; + } while (current !== void 0); + if (!isBrowser && stylesForSSR.length !== 0) { + return stylesForSSR; + } + } + }; + exports.getRegisteredStyles = getRegisteredStyles; + exports.insertStyles = insertStyles; + exports.registerStyles = registerStyles; + }); + + // node_modules/@emotion/utils/dist/emotion-utils.cjs.js + var require_emotion_utils_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_utils_cjs_dev(); + } + }); + + // node_modules/@emotion/css/create-instance/dist/emotion-css-create-instance.cjs.dev.js + var require_emotion_css_create_instance_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + var createCache = require_emotion_cache_cjs(); + var serialize = require_emotion_serialize_cjs(); + var utils = require_emotion_utils_cjs(); + function _interopDefault(e) { + return e && e.__esModule ? e : {default: e}; + } + var createCache__default = /* @__PURE__ */ _interopDefault(createCache); + function insertWithoutScoping(cache, serialized) { + if (cache.inserted[serialized.name] === void 0) { + return cache.insert("", serialized, cache.sheet, true); + } + } + function merge(registered, css, className) { + var registeredStyles = []; + var rawClassName = utils.getRegisteredStyles(registered, registeredStyles, className); + if (registeredStyles.length < 2) { + return className; + } + return rawClassName + css(registeredStyles); + } + var createEmotion = function createEmotion2(options) { + var cache = createCache__default["default"](options); + cache.sheet.speedy = function(value) { + if (this.ctr !== 0) { + throw new Error("speedy must be changed before any rules are inserted"); + } + this.isSpeedy = value; + }; + cache.compat = true; + var css = function css2() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + var serialized = serialize.serializeStyles(args, cache.registered, void 0); + utils.insertStyles(cache, serialized, false); + return cache.key + "-" + serialized.name; + }; + var keyframes = function keyframes2() { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + var serialized = serialize.serializeStyles(args, cache.registered); + var animation = "animation-" + serialized.name; + insertWithoutScoping(cache, { + name: serialized.name, + styles: "@keyframes " + animation + "{" + serialized.styles + "}" + }); + return animation; + }; + var injectGlobal = function injectGlobal2() { + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + var serialized = serialize.serializeStyles(args, cache.registered); + insertWithoutScoping(cache, serialized); + }; + var cx = function cx2() { + for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + args[_key4] = arguments[_key4]; + } + return merge(cache.registered, css, classnames(args)); + }; + return { + css, + cx, + injectGlobal, + keyframes, + hydrate: function hydrate(ids) { + ids.forEach(function(key) { + cache.inserted[key] = true; + }); + }, + flush: function flush() { + cache.registered = {}; + cache.inserted = {}; + cache.sheet.flush(); + }, + sheet: cache.sheet, + cache, + getRegisteredStyles: utils.getRegisteredStyles.bind(null, cache.registered), + merge: merge.bind(null, cache.registered, css) + }; + }; + var classnames = function classnames2(args) { + var cls = ""; + for (var i = 0; i < args.length; i++) { + var arg = args[i]; + if (arg == null) + continue; + var toAdd = void 0; + switch (typeof arg) { + case "boolean": + break; + case "object": { + if (Array.isArray(arg)) { + toAdd = classnames2(arg); + } else { + toAdd = ""; + for (var k in arg) { + if (arg[k] && k) { + toAdd && (toAdd += " "); + toAdd += k; + } + } + } + break; + } + default: { + toAdd = arg; + } + } + if (toAdd) { + cls && (cls += " "); + cls += toAdd; + } + } + return cls; + }; + exports.default = createEmotion; + }); + + // node_modules/@emotion/css/dist/emotion-css.cjs.dev.js + var require_emotion_css_cjs_dev = __commonJS((exports) => { + "use strict"; + Object.defineProperty(exports, "__esModule", {value: true}); + require_emotion_cache_cjs(); + require_emotion_serialize_cjs(); + require_emotion_utils_cjs(); + var createInstance_dist_emotionCssCreateInstance = require_emotion_css_create_instance_cjs_dev(); + var _createEmotion = createInstance_dist_emotionCssCreateInstance["default"]({ + key: "css" + }); + var flush = _createEmotion.flush; + var hydrate = _createEmotion.hydrate; + var cx = _createEmotion.cx; + var merge = _createEmotion.merge; + var getRegisteredStyles = _createEmotion.getRegisteredStyles; + var injectGlobal = _createEmotion.injectGlobal; + var keyframes = _createEmotion.keyframes; + var css = _createEmotion.css; + var sheet = _createEmotion.sheet; + var cache = _createEmotion.cache; + exports.cache = cache; + exports.css = css; + exports.cx = cx; + exports.flush = flush; + exports.getRegisteredStyles = getRegisteredStyles; + exports.hydrate = hydrate; + exports.injectGlobal = injectGlobal; + exports.keyframes = keyframes; + exports.merge = merge; + exports.sheet = sheet; + }); + + // node_modules/@emotion/css/dist/emotion-css.cjs.js + var require_emotion_css_cjs = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_emotion_css_cjs_dev(); + } + }); + + // node_modules/bs-css-emotion/src/CssJs.bs.js + var require_CssJs_bs = __commonJS((exports) => { + "use strict"; + var Js_dict = require_js_dict(); + var Css_Colors = require_Css_Colors_bs(); + var Css_Js_Core = require_Css_Js_Core_bs(); + var Css = require_emotion_css_cjs(); + function renderRaw(param, css) { + Css.injectGlobal(css); + } + function injectRules(selector2, rules) { + Css.injectGlobal(Js_dict.fromArray([[ + selector2, + rules + ]])); + } + function renderRules(param, selector2, rules) { + Css.injectGlobal(Js_dict.fromArray([[ + selector2, + rules + ]])); + } + function makeKeyframes(frames) { + return Css.keyframes(frames); + } + function renderKeyframes(param, frames) { + return Css.keyframes(frames); + } + var include = Css_Js_Core.Make({ + injectRaw: Css.injectGlobal, + renderRaw, + injectRules, + renderRules, + make: Css.css, + mergeStyles: Css.cx, + makeKeyframes, + renderKeyframes + }); + var insertRule = include.insertRule; + function fontFace(fontFamily2, src, fontStyle2, fontWeight2, fontDisplay, param) { + insertRule(Css_Js_Core.fontFace(fontFamily2, src, fontStyle2, fontWeight2, fontDisplay, void 0)); + return fontFamily2; + } + var Types = Css_Js_Core.Types; + var Make = Css_Js_Core.Make; + var toJson = Css_Js_Core.toJson; + var important = Css_Js_Core.important; + var label = Css_Js_Core.label; + var Shadow = Css_Js_Core.Shadow; + var unsafe = Css_Js_Core.unsafe; + var alignContent = Css_Js_Core.alignContent; + var alignItems = Css_Js_Core.alignItems; + var alignSelf = Css_Js_Core.alignSelf; + var animationDelay = Css_Js_Core.animationDelay; + var animationDirection = Css_Js_Core.animationDirection; + var animationDuration = Css_Js_Core.animationDuration; + var animationFillMode = Css_Js_Core.animationFillMode; + var animationIterationCount = Css_Js_Core.animationIterationCount; + var animationPlayState = Css_Js_Core.animationPlayState; + var animationTimingFunction = Css_Js_Core.animationTimingFunction; + var backdropFilter = Css_Js_Core.backdropFilter; + var backfaceVisibility = Css_Js_Core.backfaceVisibility; + var backgroundAttachment = Css_Js_Core.backgroundAttachment; + var backgroundColor = Css_Js_Core.backgroundColor; + var backgroundClip = Css_Js_Core.backgroundClip; + var backgroundImage = Css_Js_Core.backgroundImage; + var maskImage = Css_Js_Core.maskImage; + var backgroundOrigin = Css_Js_Core.backgroundOrigin; + var backgroundPosition = Css_Js_Core.backgroundPosition; + var backgroundPositions = Css_Js_Core.backgroundPositions; + var backgroundPosition4 = Css_Js_Core.backgroundPosition4; + var maskPosition = Css_Js_Core.maskPosition; + var maskPositions = Css_Js_Core.maskPositions; + var backgroundRepeat = Css_Js_Core.backgroundRepeat; + var borderBottom = Css_Js_Core.borderBottom; + var borderBottomColor = Css_Js_Core.borderBottomColor; + var borderBottomLeftRadius = Css_Js_Core.borderBottomLeftRadius; + var borderBottomRightRadius = Css_Js_Core.borderBottomRightRadius; + var borderBottomStyle = Css_Js_Core.borderBottomStyle; + var borderBottomWidth = Css_Js_Core.borderBottomWidth; + var borderCollapse = Css_Js_Core.borderCollapse; + var borderColor = Css_Js_Core.borderColor; + var borderLeft = Css_Js_Core.borderLeft; + var borderLeftColor = Css_Js_Core.borderLeftColor; + var borderLeftStyle = Css_Js_Core.borderLeftStyle; + var borderLeftWidth = Css_Js_Core.borderLeftWidth; + var borderRight = Css_Js_Core.borderRight; + var borderRightColor = Css_Js_Core.borderRightColor; + var borderRightStyle = Css_Js_Core.borderRightStyle; + var borderRightWidth = Css_Js_Core.borderRightWidth; + var borderRadius = Css_Js_Core.borderRadius; + var borderRadius4 = Css_Js_Core.borderRadius4; + var borderSpacing = Css_Js_Core.borderSpacing; + var borderStyle = Css_Js_Core.borderStyle; + var borderTopColor = Css_Js_Core.borderTopColor; + var borderTopLeftRadius = Css_Js_Core.borderTopLeftRadius; + var borderTopRightRadius = Css_Js_Core.borderTopRightRadius; + var borderTopStyle = Css_Js_Core.borderTopStyle; + var borderTopWidth = Css_Js_Core.borderTopWidth; + var borderWidth = Css_Js_Core.borderWidth; + var bottom = Css_Js_Core.bottom; + var boxSizing = Css_Js_Core.boxSizing; + var boxShadow = Css_Js_Core.boxShadow; + var boxShadows = Css_Js_Core.boxShadows; + var clear = Css_Js_Core.clear; + var clipPath = Css_Js_Core.clipPath; + var color = Css_Js_Core.color; + var columnCount = Css_Js_Core.columnCount; + var contentRule = Css_Js_Core.contentRule; + var contentRules = Css_Js_Core.contentRules; + var counterIncrement = Css_Js_Core.counterIncrement; + var countersIncrement = Css_Js_Core.countersIncrement; + var counterReset = Css_Js_Core.counterReset; + var countersReset = Css_Js_Core.countersReset; + var counterSet = Css_Js_Core.counterSet; + var countersSet = Css_Js_Core.countersSet; + var cursor = Css_Js_Core.cursor; + var direction = Css_Js_Core.direction; + var display = Css_Js_Core.display; + var flex = Css_Js_Core.flex; + var flexBasis = Css_Js_Core.flexBasis; + var flexDirection = Css_Js_Core.flexDirection; + var flexGrow = Css_Js_Core.flexGrow; + var flexShrink = Css_Js_Core.flexShrink; + var flexWrap = Css_Js_Core.flexWrap; + var $$float = Css_Js_Core.$$float; + var fontFamily = Css_Js_Core.fontFamily; + var fontFamilies = Css_Js_Core.fontFamilies; + var fontSize = Css_Js_Core.fontSize; + var fontStyle = Css_Js_Core.fontStyle; + var fontVariant = Css_Js_Core.fontVariant; + var fontWeight = Css_Js_Core.fontWeight; + var gridArea = Css_Js_Core.gridArea; + var gridArea2 = Css_Js_Core.gridArea2; + var gridArea3 = Css_Js_Core.gridArea3; + var gridArea4 = Css_Js_Core.gridArea4; + var gridAutoFlow = Css_Js_Core.gridAutoFlow; + var gridColumn = Css_Js_Core.gridColumn; + var gridColumnEnd = Css_Js_Core.gridColumnEnd; + var columnGap = Css_Js_Core.columnGap; + var scrollBehavior = Css_Js_Core.scrollBehavior; + var overscrollBehavior = Css_Js_Core.overscrollBehavior; + var overflowAnchor = Css_Js_Core.overflowAnchor; + var columnWidth = Css_Js_Core.columnWidth; + var caretColor = Css_Js_Core.caretColor; + var gridColumnGap = Css_Js_Core.gridColumnGap; + var gridColumnStart = Css_Js_Core.gridColumnStart; + var gap = Css_Js_Core.gap; + var gap2 = Css_Js_Core.gap2; + var gridGap = Css_Js_Core.gridGap; + var gridRow = Css_Js_Core.gridRow; + var gridRowEnd = Css_Js_Core.gridRowEnd; + var gridRowGap = Css_Js_Core.gridRowGap; + var rowGap = Css_Js_Core.rowGap; + var gridRowStart = Css_Js_Core.gridRowStart; + var gridTemplateAreas = Css_Js_Core.gridTemplateAreas; + var height = Css_Js_Core.height; + var justifyContent = Css_Js_Core.justifyContent; + var justifyItems = Css_Js_Core.justifyItems; + var justifySelf = Css_Js_Core.justifySelf; + var left = Css_Js_Core.left; + var letterSpacing = Css_Js_Core.letterSpacing; + var lineHeight = Css_Js_Core.lineHeight; + var listStyle = Css_Js_Core.listStyle; + var listStyleImage = Css_Js_Core.listStyleImage; + var listStyleType = Css_Js_Core.listStyleType; + var listStylePosition = Css_Js_Core.listStylePosition; + var margin = Css_Js_Core.margin; + var margin2 = Css_Js_Core.margin2; + var margin3 = Css_Js_Core.margin3; + var margin4 = Css_Js_Core.margin4; + var marginLeft = Css_Js_Core.marginLeft; + var marginRight = Css_Js_Core.marginRight; + var marginTop = Css_Js_Core.marginTop; + var marginBottom = Css_Js_Core.marginBottom; + var maxHeight = Css_Js_Core.maxHeight; + var maxWidth = Css_Js_Core.maxWidth; + var minHeight = Css_Js_Core.minHeight; + var minWidth = Css_Js_Core.minWidth; + var objectFit = Css_Js_Core.objectFit; + var objectPosition = Css_Js_Core.objectPosition; + var opacity = Css_Js_Core.opacity; + var order = Css_Js_Core.order; + var outline = Css_Js_Core.outline; + var outlineColor = Css_Js_Core.outlineColor; + var outlineOffset = Css_Js_Core.outlineOffset; + var outlineStyle = Css_Js_Core.outlineStyle; + var outlineWidth = Css_Js_Core.outlineWidth; + var overflow = Css_Js_Core.overflow; + var overflowX = Css_Js_Core.overflowX; + var overflowY = Css_Js_Core.overflowY; + var overflowWrap = Css_Js_Core.overflowWrap; + var padding = Css_Js_Core.padding; + var padding2 = Css_Js_Core.padding2; + var padding3 = Css_Js_Core.padding3; + var padding4 = Css_Js_Core.padding4; + var paddingLeft = Css_Js_Core.paddingLeft; + var paddingRight = Css_Js_Core.paddingRight; + var paddingTop = Css_Js_Core.paddingTop; + var paddingBottom = Css_Js_Core.paddingBottom; + var perspective = Css_Js_Core.perspective; + var perspectiveOrigin = Css_Js_Core.perspectiveOrigin; + var pointerEvents = Css_Js_Core.pointerEvents; + var position = Css_Js_Core.position; + var isolation = Css_Js_Core.isolation; + var resize = Css_Js_Core.resize; + var right = Css_Js_Core.right; + var tableLayout = Css_Js_Core.tableLayout; + var textAlign = Css_Js_Core.textAlign; + var textDecorationColor = Css_Js_Core.textDecorationColor; + var textDecorationLine = Css_Js_Core.textDecorationLine; + var textDecorationStyle = Css_Js_Core.textDecorationStyle; + var textIndent = Css_Js_Core.textIndent; + var textOverflow = Css_Js_Core.textOverflow; + var textShadow = Css_Js_Core.textShadow; + var textShadows = Css_Js_Core.textShadows; + var textTransform = Css_Js_Core.textTransform; + var top = Css_Js_Core.top; + var transform = Css_Js_Core.transform; + var transforms = Css_Js_Core.transforms; + var transformOrigin = Css_Js_Core.transformOrigin; + var transformOrigin3d = Css_Js_Core.transformOrigin3d; + var transitionDelay = Css_Js_Core.transitionDelay; + var transitionDuration = Css_Js_Core.transitionDuration; + var transitionProperty = Css_Js_Core.transitionProperty; + var transformStyle = Css_Js_Core.transformStyle; + var transitionTimingFunction = Css_Js_Core.transitionTimingFunction; + var userSelect = Css_Js_Core.userSelect; + var verticalAlign = Css_Js_Core.verticalAlign; + var visibility = Css_Js_Core.visibility; + var width = Css_Js_Core.width; + var whiteSpace = Css_Js_Core.whiteSpace; + var wordBreak = Css_Js_Core.wordBreak; + var wordSpacing = Css_Js_Core.wordSpacing; + var wordWrap = Css_Js_Core.wordWrap; + var zIndex = Css_Js_Core.zIndex; + var selector = Css_Js_Core.selector; + var media = Css_Js_Core.media; + var active = Css_Js_Core.active; + var checked = Css_Js_Core.checked; + var $$default = Css_Js_Core.$$default; + var defined = Css_Js_Core.defined; + var disabled = Css_Js_Core.disabled; + var empty = Css_Js_Core.empty; + var enabled = Css_Js_Core.enabled; + var first = Css_Js_Core.first; + var firstChild = Css_Js_Core.firstChild; + var firstOfType = Css_Js_Core.firstOfType; + var focus = Css_Js_Core.focus; + var focusVisible = Css_Js_Core.focusVisible; + var focusWithin = Css_Js_Core.focusWithin; + var host = Css_Js_Core.host; + var hover = Css_Js_Core.hover; + var indeterminate = Css_Js_Core.indeterminate; + var inRange = Css_Js_Core.inRange; + var invalid = Css_Js_Core.invalid; + var lang = Css_Js_Core.lang; + var lastChild = Css_Js_Core.lastChild; + var lastOfType = Css_Js_Core.lastOfType; + var link = Css_Js_Core.link; + var not_ = Css_Js_Core.not_; + var Nth = Css_Js_Core.Nth; + var nthChild = Css_Js_Core.nthChild; + var nthLastChild = Css_Js_Core.nthLastChild; + var nthLastOfType = Css_Js_Core.nthLastOfType; + var nthOfType = Css_Js_Core.nthOfType; + var onlyChild = Css_Js_Core.onlyChild; + var onlyOfType = Css_Js_Core.onlyOfType; + var optional = Css_Js_Core.optional; + var outOfRange = Css_Js_Core.outOfRange; + var readOnly = Css_Js_Core.readOnly; + var readWrite = Css_Js_Core.readWrite; + var required = Css_Js_Core.required; + var root = Css_Js_Core.root; + var scope = Css_Js_Core.scope; + var target = Css_Js_Core.target; + var valid = Css_Js_Core.valid; + var visited = Css_Js_Core.visited; + var after = Css_Js_Core.after; + var before = Css_Js_Core.before; + var firstLetter = Css_Js_Core.firstLetter; + var firstLine = Css_Js_Core.firstLine; + var placeholder = Css_Js_Core.placeholder; + var selection = Css_Js_Core.selection; + var child = Css_Js_Core.child; + var children = Css_Js_Core.children; + var directSibling = Css_Js_Core.directSibling; + var siblings = Css_Js_Core.siblings; + var anyLink = Css_Js_Core.anyLink; + var initial = Css_Js_Core.initial; + var inherit_ = Css_Js_Core.inherit_; + var unset = Css_Js_Core.unset; + var $$var = Css_Js_Core.$$var; + var varDefault = Css_Js_Core.varDefault; + var auto = Css_Js_Core.auto; + var none = Css_Js_Core.none; + var text = Css_Js_Core.text; + var pct = Css_Js_Core.pct; + var ch = Css_Js_Core.ch; + var cm = Css_Js_Core.cm; + var em = Css_Js_Core.em; + var ex = Css_Js_Core.ex; + var mm = Css_Js_Core.mm; + var pt = Css_Js_Core.pt; + var px = Css_Js_Core.px; + var pxFloat = Css_Js_Core.pxFloat; + var rem = Css_Js_Core.rem; + var vh = Css_Js_Core.vh; + var vmin = Css_Js_Core.vmin; + var vmax = Css_Js_Core.vmax; + var zero = Css_Js_Core.zero; + var deg = Css_Js_Core.deg; + var rad = Css_Js_Core.rad; + var grad = Css_Js_Core.grad; + var turn = Css_Js_Core.turn; + var ltr = Css_Js_Core.ltr; + var rtl = Css_Js_Core.rtl; + var absolute = Css_Js_Core.absolute; + var relative = Css_Js_Core.relative; + var $$static = Css_Js_Core.$$static; + var fixed = Css_Js_Core.fixed; + var sticky = Css_Js_Core.sticky; + var isolate = Css_Js_Core.isolate; + var horizontal = Css_Js_Core.horizontal; + var vertical = Css_Js_Core.vertical; + var smallCaps = Css_Js_Core.smallCaps; + var italic = Css_Js_Core.italic; + var oblique = Css_Js_Core.oblique; + var hidden = Css_Js_Core.hidden; + var visible = Css_Js_Core.visible; + var scroll = Css_Js_Core.scroll; + var rgb = Css_Js_Core.rgb; + var rgba = Css_Js_Core.rgba; + var hsl = Css_Js_Core.hsl; + var hsla = Css_Js_Core.hsla; + var hex = Css_Js_Core.hex; + var currentColor = Css_Js_Core.currentColor; + var local = Css_Js_Core.local; + var paddingBox = Css_Js_Core.paddingBox; + var borderBox = Css_Js_Core.borderBox; + var contentBox = Css_Js_Core.contentBox; + var noRepeat = Css_Js_Core.noRepeat; + var space = Css_Js_Core.space; + var repeat = Css_Js_Core.repeat; + var minmax = Css_Js_Core.minmax; + var repeatX = Css_Js_Core.repeatX; + var repeatY = Css_Js_Core.repeatY; + var contain = Css_Js_Core.contain; + var cover = Css_Js_Core.cover; + var row = Css_Js_Core.row; + var rowReverse = Css_Js_Core.rowReverse; + var column = Css_Js_Core.column; + var columnReverse = Css_Js_Core.columnReverse; + var wrap = Css_Js_Core.wrap; + var nowrap = Css_Js_Core.nowrap; + var wrapReverse = Css_Js_Core.wrapReverse; + var inline = Css_Js_Core.inline; + var block = Css_Js_Core.block; + var contents = Css_Js_Core.contents; + var flexBox = Css_Js_Core.flexBox; + var grid = Css_Js_Core.grid; + var inlineBlock = Css_Js_Core.inlineBlock; + var inlineFlex = Css_Js_Core.inlineFlex; + var inlineGrid = Css_Js_Core.inlineGrid; + var inlineTable = Css_Js_Core.inlineTable; + var listItem = Css_Js_Core.listItem; + var runIn = Css_Js_Core.runIn; + var table = Css_Js_Core.table; + var tableCaption = Css_Js_Core.tableCaption; + var tableColumnGroup = Css_Js_Core.tableColumnGroup; + var tableHeaderGroup = Css_Js_Core.tableHeaderGroup; + var tableFooterGroup = Css_Js_Core.tableFooterGroup; + var tableRowGroup = Css_Js_Core.tableRowGroup; + var tableCell = Css_Js_Core.tableCell; + var tableColumn = Css_Js_Core.tableColumn; + var tableRow = Css_Js_Core.tableRow; + var flexStart = Css_Js_Core.flexStart; + var flexEnd = Css_Js_Core.flexEnd; + var center = Css_Js_Core.center; + var stretch = Css_Js_Core.stretch; + var spaceBetween = Css_Js_Core.spaceBetween; + var spaceAround = Css_Js_Core.spaceAround; + var spaceEvenly = Css_Js_Core.spaceEvenly; + var baseline = Css_Js_Core.baseline; + var forwards = Css_Js_Core.forwards; + var backwards = Css_Js_Core.backwards; + var both = Css_Js_Core.both; + var infinite = Css_Js_Core.infinite; + var count = Css_Js_Core.count; + var paused = Css_Js_Core.paused; + var running = Css_Js_Core.running; + var inside = Css_Js_Core.inside; + var outside = Css_Js_Core.outside; + var solid = Css_Js_Core.solid; + var dotted = Css_Js_Core.dotted; + var dashed = Css_Js_Core.dashed; + var underline = Css_Js_Core.underline; + var overline = Css_Js_Core.overline; + var lineThrough = Css_Js_Core.lineThrough; + var clip = Css_Js_Core.clip; + var ellipsis = Css_Js_Core.ellipsis; + var wavy = Css_Js_Core.wavy; + var $$double = Css_Js_Core.$$double; + var uppercase = Css_Js_Core.uppercase; + var lowercase = Css_Js_Core.lowercase; + var capitalize = Css_Js_Core.capitalize; + var sub = Css_Js_Core.sub; + var $$super = Css_Js_Core.$$super; + var textTop = Css_Js_Core.textTop; + var textBottom = Css_Js_Core.textBottom; + var middle = Css_Js_Core.middle; + var normal = Css_Js_Core.normal; + var breakAll = Css_Js_Core.breakAll; + var keepAll = Css_Js_Core.keepAll; + var breakWord = Css_Js_Core.breakWord; + var reverse = Css_Js_Core.reverse; + var alternate = Css_Js_Core.alternate; + var alternateReverse = Css_Js_Core.alternateReverse; + var fill = Css_Js_Core.fill; + var content = Css_Js_Core.content; + var maxContent = Css_Js_Core.maxContent; + var minContent = Css_Js_Core.minContent; + var fitContent = Css_Js_Core.fitContent; + var all = Css_Js_Core.all; + var round = Css_Js_Core.round; + var miter = Css_Js_Core.miter; + var bevel = Css_Js_Core.bevel; + var butt = Css_Js_Core.butt; + var square = Css_Js_Core.square; + var panX = Css_Js_Core.panX; + var panY = Css_Js_Core.panY; + var panLeft = Css_Js_Core.panLeft; + var panRight = Css_Js_Core.panRight; + var panUp = Css_Js_Core.panUp; + var panDown = Css_Js_Core.panDown; + var pinchZoom = Css_Js_Core.pinchZoom; + var manipulation = Css_Js_Core.manipulation; + var thin = Css_Js_Core.thin; + var extraLight = Css_Js_Core.extraLight; + var light = Css_Js_Core.light; + var medium = Css_Js_Core.medium; + var semiBold = Css_Js_Core.semiBold; + var bold = Css_Js_Core.bold; + var extraBold = Css_Js_Core.extraBold; + var lighter = Css_Js_Core.lighter; + var bolder = Css_Js_Core.bolder; + var fr = Css_Js_Core.fr; + var vw = Css_Js_Core.vw; + var localUrl = Css_Js_Core.localUrl; + var url = Css_Js_Core.url; + var linear = Css_Js_Core.linear; + var ease = Css_Js_Core.ease; + var easeIn = Css_Js_Core.easeIn; + var easeOut = Css_Js_Core.easeOut; + var easeInOut = Css_Js_Core.easeInOut; + var stepStart = Css_Js_Core.stepStart; + var stepEnd = Css_Js_Core.stepEnd; + var steps = Css_Js_Core.steps; + var cubicBezier = Css_Js_Core.cubicBezier; + var marginBox = Css_Js_Core.marginBox; + var fillBox = Css_Js_Core.fillBox; + var strokeBox = Css_Js_Core.strokeBox; + var viewBox = Css_Js_Core.viewBox; + var translate = Css_Js_Core.translate; + var translate3d = Css_Js_Core.translate3d; + var translateX = Css_Js_Core.translateX; + var translateY = Css_Js_Core.translateY; + var translateZ = Css_Js_Core.translateZ; + var scale = Css_Js_Core.scale; + var scale3d = Css_Js_Core.scale3d; + var scaleX = Css_Js_Core.scaleX; + var scaleY = Css_Js_Core.scaleY; + var scaleZ = Css_Js_Core.scaleZ; + var rotate = Css_Js_Core.rotate; + var rotate3d = Css_Js_Core.rotate3d; + var rotateX = Css_Js_Core.rotateX; + var rotateY = Css_Js_Core.rotateY; + var rotateZ = Css_Js_Core.rotateZ; + var skew = Css_Js_Core.skew; + var skewX = Css_Js_Core.skewX; + var skewY = Css_Js_Core.skewY; + var linearGradient = Css_Js_Core.linearGradient; + var repeatingLinearGradient = Css_Js_Core.repeatingLinearGradient; + var radialGradient = Css_Js_Core.radialGradient; + var repeatingRadialGradient = Css_Js_Core.repeatingRadialGradient; + var conicGradient = Css_Js_Core.conicGradient; + var areas = Css_Js_Core.areas; + var ident = Css_Js_Core.ident; + var numIdent = Css_Js_Core.numIdent; + var contextMenu = Css_Js_Core.contextMenu; + var help = Css_Js_Core.help; + var pointer = Css_Js_Core.pointer; + var progress = Css_Js_Core.progress; + var wait = Css_Js_Core.wait; + var cell = Css_Js_Core.cell; + var crosshair = Css_Js_Core.crosshair; + var verticalText = Css_Js_Core.verticalText; + var alias = Css_Js_Core.alias; + var copy = Css_Js_Core.copy; + var move = Css_Js_Core.move; + var noDrop = Css_Js_Core.noDrop; + var notAllowed = Css_Js_Core.notAllowed; + var grab = Css_Js_Core.grab; + var grabbing = Css_Js_Core.grabbing; + var allScroll = Css_Js_Core.allScroll; + var colResize = Css_Js_Core.colResize; + var rowResize = Css_Js_Core.rowResize; + var nResize = Css_Js_Core.nResize; + var eResize = Css_Js_Core.eResize; + var sResize = Css_Js_Core.sResize; + var wResize = Css_Js_Core.wResize; + var neResize = Css_Js_Core.neResize; + var nwResize = Css_Js_Core.nwResize; + var seResize = Css_Js_Core.seResize; + var swResize = Css_Js_Core.swResize; + var ewResize = Css_Js_Core.ewResize; + var nsResize = Css_Js_Core.nsResize; + var neswResize = Css_Js_Core.neswResize; + var nwseResize = Css_Js_Core.nwseResize; + var zoomIn = Css_Js_Core.zoomIn; + var zoomOut = Css_Js_Core.zoomOut; + var flex3 = Css_Js_Core.flex3; + var border = Css_Js_Core.border; + var borderTop = Css_Js_Core.borderTop; + var backgroundSize = Css_Js_Core.backgroundSize; + var textDecoration = Css_Js_Core.textDecoration; + var background = Css_Js_Core.background; + var backgrounds = Css_Js_Core.backgrounds; + var gridAutoColumns = Css_Js_Core.gridAutoColumns; + var gridAutoRows = Css_Js_Core.gridAutoRows; + var gridTemplateColumns = Css_Js_Core.gridTemplateColumns; + var gridTemplateRows = Css_Js_Core.gridTemplateRows; + var Calc = Css_Js_Core.Calc; + var size = Css_Js_Core.size; + var filter = Css_Js_Core.filter; + var Transition = Css_Js_Core.Transition; + var transitionValue = Css_Js_Core.transitionValue; + var transitionList = Css_Js_Core.transitionList; + var transition = Css_Js_Core.transition; + var transitions = Css_Js_Core.transitions; + var Animation = Css_Js_Core.Animation; + var animationValue = Css_Js_Core.animationValue; + var animation = Css_Js_Core.animation; + var animations = Css_Js_Core.animations; + var animationName = Css_Js_Core.animationName; + var SVG = Css_Js_Core.SVG; + var touchAction = Css_Js_Core.touchAction; + var aliceblue = Css_Colors.aliceblue; + var antiquewhite = Css_Colors.antiquewhite; + var aqua = Css_Colors.aqua; + var aquamarine = Css_Colors.aquamarine; + var azure = Css_Colors.azure; + var beige = Css_Colors.beige; + var bisque = Css_Colors.bisque; + var black = Css_Colors.black; + var blanchedalmond = Css_Colors.blanchedalmond; + var blue = Css_Colors.blue; + var blueviolet = Css_Colors.blueviolet; + var brown = Css_Colors.brown; + var burlywood = Css_Colors.burlywood; + var cadetblue = Css_Colors.cadetblue; + var chartreuse = Css_Colors.chartreuse; + var chocolate = Css_Colors.chocolate; + var coral = Css_Colors.coral; + var cornflowerblue = Css_Colors.cornflowerblue; + var cornsilk = Css_Colors.cornsilk; + var crimson = Css_Colors.crimson; + var cyan = Css_Colors.cyan; + var darkblue = Css_Colors.darkblue; + var darkcyan = Css_Colors.darkcyan; + var darkgoldenrod = Css_Colors.darkgoldenrod; + var darkgray = Css_Colors.darkgray; + var darkgreen = Css_Colors.darkgreen; + var darkgrey = Css_Colors.darkgrey; + var darkkhaki = Css_Colors.darkkhaki; + var darkmagenta = Css_Colors.darkmagenta; + var darkolivegreen = Css_Colors.darkolivegreen; + var darkorange = Css_Colors.darkorange; + var darkorchid = Css_Colors.darkorchid; + var darkred = Css_Colors.darkred; + var darksalmon = Css_Colors.darksalmon; + var darkseagreen = Css_Colors.darkseagreen; + var darkslateblue = Css_Colors.darkslateblue; + var darkslategray = Css_Colors.darkslategray; + var darkslategrey = Css_Colors.darkslategrey; + var darkturquoise = Css_Colors.darkturquoise; + var darkviolet = Css_Colors.darkviolet; + var deeppink = Css_Colors.deeppink; + var deepskyblue = Css_Colors.deepskyblue; + var dimgray = Css_Colors.dimgray; + var dimgrey = Css_Colors.dimgrey; + var dodgerblue = Css_Colors.dodgerblue; + var firebrick = Css_Colors.firebrick; + var floralwhite = Css_Colors.floralwhite; + var forestgreen = Css_Colors.forestgreen; + var fuchsia = Css_Colors.fuchsia; + var gainsboro = Css_Colors.gainsboro; + var ghostwhite = Css_Colors.ghostwhite; + var gold = Css_Colors.gold; + var goldenrod = Css_Colors.goldenrod; + var gray = Css_Colors.gray; + var green = Css_Colors.green; + var greenyellow = Css_Colors.greenyellow; + var grey = Css_Colors.grey; + var honeydew = Css_Colors.honeydew; + var hotpink = Css_Colors.hotpink; + var indianred = Css_Colors.indianred; + var indigo = Css_Colors.indigo; + var ivory = Css_Colors.ivory; + var khaki = Css_Colors.khaki; + var lavender = Css_Colors.lavender; + var lavenderblush = Css_Colors.lavenderblush; + var lawngreen = Css_Colors.lawngreen; + var lemonchiffon = Css_Colors.lemonchiffon; + var lightblue = Css_Colors.lightblue; + var lightcoral = Css_Colors.lightcoral; + var lightcyan = Css_Colors.lightcyan; + var lightgoldenrodyellow = Css_Colors.lightgoldenrodyellow; + var lightgray = Css_Colors.lightgray; + var lightgreen = Css_Colors.lightgreen; + var lightgrey = Css_Colors.lightgrey; + var lightpink = Css_Colors.lightpink; + var lightsalmon = Css_Colors.lightsalmon; + var lightseagreen = Css_Colors.lightseagreen; + var lightskyblue = Css_Colors.lightskyblue; + var lightslategray = Css_Colors.lightslategray; + var lightslategrey = Css_Colors.lightslategrey; + var lightsteelblue = Css_Colors.lightsteelblue; + var lightyellow = Css_Colors.lightyellow; + var lime = Css_Colors.lime; + var limegreen = Css_Colors.limegreen; + var linen = Css_Colors.linen; + var magenta = Css_Colors.magenta; + var maroon = Css_Colors.maroon; + var mediumaquamarine = Css_Colors.mediumaquamarine; + var mediumblue = Css_Colors.mediumblue; + var mediumorchid = Css_Colors.mediumorchid; + var mediumpurple = Css_Colors.mediumpurple; + var mediumseagreen = Css_Colors.mediumseagreen; + var mediumslateblue = Css_Colors.mediumslateblue; + var mediumspringgreen = Css_Colors.mediumspringgreen; + var mediumturquoise = Css_Colors.mediumturquoise; + var mediumvioletred = Css_Colors.mediumvioletred; + var midnightblue = Css_Colors.midnightblue; + var mintcream = Css_Colors.mintcream; + var mistyrose = Css_Colors.mistyrose; + var moccasin = Css_Colors.moccasin; + var navajowhite = Css_Colors.navajowhite; + var navy = Css_Colors.navy; + var oldlace = Css_Colors.oldlace; + var olive = Css_Colors.olive; + var olivedrab = Css_Colors.olivedrab; + var orange = Css_Colors.orange; + var orangered = Css_Colors.orangered; + var orchid = Css_Colors.orchid; + var palegoldenrod = Css_Colors.palegoldenrod; + var palegreen = Css_Colors.palegreen; + var paleturquoise = Css_Colors.paleturquoise; + var palevioletred = Css_Colors.palevioletred; + var papayawhip = Css_Colors.papayawhip; + var peachpuff = Css_Colors.peachpuff; + var peru = Css_Colors.peru; + var pink = Css_Colors.pink; + var plum = Css_Colors.plum; + var powderblue = Css_Colors.powderblue; + var purple = Css_Colors.purple; + var rebeccapurple = Css_Colors.rebeccapurple; + var red = Css_Colors.red; + var rosybrown = Css_Colors.rosybrown; + var royalblue = Css_Colors.royalblue; + var saddlebrown = Css_Colors.saddlebrown; + var salmon = Css_Colors.salmon; + var sandybrown = Css_Colors.sandybrown; + var seagreen = Css_Colors.seagreen; + var seashell = Css_Colors.seashell; + var sienna = Css_Colors.sienna; + var silver = Css_Colors.silver; + var skyblue = Css_Colors.skyblue; + var slateblue = Css_Colors.slateblue; + var slategray = Css_Colors.slategray; + var slategrey = Css_Colors.slategrey; + var snow = Css_Colors.snow; + var springgreen = Css_Colors.springgreen; + var steelblue = Css_Colors.steelblue; + var tan = Css_Colors.tan; + var teal = Css_Colors.teal; + var thistle = Css_Colors.thistle; + var tomato = Css_Colors.tomato; + var turquoise = Css_Colors.turquoise; + var violet = Css_Colors.violet; + var wheat = Css_Colors.wheat; + var white = Css_Colors.white; + var whitesmoke = Css_Colors.whitesmoke; + var yellow = Css_Colors.yellow; + var yellowgreen = Css_Colors.yellowgreen; + var transparent = Css_Colors.transparent; + var renderRule = include.renderRule; + var $$global = include.$$global; + var renderGlobal = include.renderGlobal; + var style = include.style; + var merge = include.merge; + var merge2 = include.merge2; + var merge3 = include.merge3; + var merge4 = include.merge4; + var keyframes = include.keyframes; + var renderKeyframes$1 = include.renderKeyframes; + exports.Types = Types; + exports.Make = Make; + exports.toJson = toJson; + exports.important = important; + exports.label = label; + exports.Shadow = Shadow; + exports.unsafe = unsafe; + exports.alignContent = alignContent; + exports.alignItems = alignItems; + exports.alignSelf = alignSelf; + exports.animationDelay = animationDelay; + exports.animationDirection = animationDirection; + exports.animationDuration = animationDuration; + exports.animationFillMode = animationFillMode; + exports.animationIterationCount = animationIterationCount; + exports.animationPlayState = animationPlayState; + exports.animationTimingFunction = animationTimingFunction; + exports.backdropFilter = backdropFilter; + exports.backfaceVisibility = backfaceVisibility; + exports.backgroundAttachment = backgroundAttachment; + exports.backgroundColor = backgroundColor; + exports.backgroundClip = backgroundClip; + exports.backgroundImage = backgroundImage; + exports.maskImage = maskImage; + exports.backgroundOrigin = backgroundOrigin; + exports.backgroundPosition = backgroundPosition; + exports.backgroundPositions = backgroundPositions; + exports.backgroundPosition4 = backgroundPosition4; + exports.maskPosition = maskPosition; + exports.maskPositions = maskPositions; + exports.backgroundRepeat = backgroundRepeat; + exports.borderBottom = borderBottom; + exports.borderBottomColor = borderBottomColor; + exports.borderBottomLeftRadius = borderBottomLeftRadius; + exports.borderBottomRightRadius = borderBottomRightRadius; + exports.borderBottomStyle = borderBottomStyle; + exports.borderBottomWidth = borderBottomWidth; + exports.borderCollapse = borderCollapse; + exports.borderColor = borderColor; + exports.borderLeft = borderLeft; + exports.borderLeftColor = borderLeftColor; + exports.borderLeftStyle = borderLeftStyle; + exports.borderLeftWidth = borderLeftWidth; + exports.borderRight = borderRight; + exports.borderRightColor = borderRightColor; + exports.borderRightStyle = borderRightStyle; + exports.borderRightWidth = borderRightWidth; + exports.borderRadius = borderRadius; + exports.borderRadius4 = borderRadius4; + exports.borderSpacing = borderSpacing; + exports.borderStyle = borderStyle; + exports.borderTopColor = borderTopColor; + exports.borderTopLeftRadius = borderTopLeftRadius; + exports.borderTopRightRadius = borderTopRightRadius; + exports.borderTopStyle = borderTopStyle; + exports.borderTopWidth = borderTopWidth; + exports.borderWidth = borderWidth; + exports.bottom = bottom; + exports.boxSizing = boxSizing; + exports.boxShadow = boxShadow; + exports.boxShadows = boxShadows; + exports.clear = clear; + exports.clipPath = clipPath; + exports.color = color; + exports.columnCount = columnCount; + exports.contentRule = contentRule; + exports.contentRules = contentRules; + exports.counterIncrement = counterIncrement; + exports.countersIncrement = countersIncrement; + exports.counterReset = counterReset; + exports.countersReset = countersReset; + exports.counterSet = counterSet; + exports.countersSet = countersSet; + exports.cursor = cursor; + exports.direction = direction; + exports.display = display; + exports.flex = flex; + exports.flexBasis = flexBasis; + exports.flexDirection = flexDirection; + exports.flexGrow = flexGrow; + exports.flexShrink = flexShrink; + exports.flexWrap = flexWrap; + exports.$$float = $$float; + exports.fontFamily = fontFamily; + exports.fontFamilies = fontFamilies; + exports.fontSize = fontSize; + exports.fontStyle = fontStyle; + exports.fontVariant = fontVariant; + exports.fontWeight = fontWeight; + exports.gridArea = gridArea; + exports.gridArea2 = gridArea2; + exports.gridArea3 = gridArea3; + exports.gridArea4 = gridArea4; + exports.gridAutoFlow = gridAutoFlow; + exports.gridColumn = gridColumn; + exports.gridColumnEnd = gridColumnEnd; + exports.columnGap = columnGap; + exports.scrollBehavior = scrollBehavior; + exports.overscrollBehavior = overscrollBehavior; + exports.overflowAnchor = overflowAnchor; + exports.columnWidth = columnWidth; + exports.caretColor = caretColor; + exports.gridColumnGap = gridColumnGap; + exports.gridColumnStart = gridColumnStart; + exports.gap = gap; + exports.gap2 = gap2; + exports.gridGap = gridGap; + exports.gridRow = gridRow; + exports.gridRowEnd = gridRowEnd; + exports.gridRowGap = gridRowGap; + exports.rowGap = rowGap; + exports.gridRowStart = gridRowStart; + exports.gridTemplateAreas = gridTemplateAreas; + exports.height = height; + exports.justifyContent = justifyContent; + exports.justifyItems = justifyItems; + exports.justifySelf = justifySelf; + exports.left = left; + exports.letterSpacing = letterSpacing; + exports.lineHeight = lineHeight; + exports.listStyle = listStyle; + exports.listStyleImage = listStyleImage; + exports.listStyleType = listStyleType; + exports.listStylePosition = listStylePosition; + exports.margin = margin; + exports.margin2 = margin2; + exports.margin3 = margin3; + exports.margin4 = margin4; + exports.marginLeft = marginLeft; + exports.marginRight = marginRight; + exports.marginTop = marginTop; + exports.marginBottom = marginBottom; + exports.maxHeight = maxHeight; + exports.maxWidth = maxWidth; + exports.minHeight = minHeight; + exports.minWidth = minWidth; + exports.objectFit = objectFit; + exports.objectPosition = objectPosition; + exports.opacity = opacity; + exports.order = order; + exports.outline = outline; + exports.outlineColor = outlineColor; + exports.outlineOffset = outlineOffset; + exports.outlineStyle = outlineStyle; + exports.outlineWidth = outlineWidth; + exports.overflow = overflow; + exports.overflowX = overflowX; + exports.overflowY = overflowY; + exports.overflowWrap = overflowWrap; + exports.padding = padding; + exports.padding2 = padding2; + exports.padding3 = padding3; + exports.padding4 = padding4; + exports.paddingLeft = paddingLeft; + exports.paddingRight = paddingRight; + exports.paddingTop = paddingTop; + exports.paddingBottom = paddingBottom; + exports.perspective = perspective; + exports.perspectiveOrigin = perspectiveOrigin; + exports.pointerEvents = pointerEvents; + exports.position = position; + exports.isolation = isolation; + exports.resize = resize; + exports.right = right; + exports.tableLayout = tableLayout; + exports.textAlign = textAlign; + exports.textDecorationColor = textDecorationColor; + exports.textDecorationLine = textDecorationLine; + exports.textDecorationStyle = textDecorationStyle; + exports.textIndent = textIndent; + exports.textOverflow = textOverflow; + exports.textShadow = textShadow; + exports.textShadows = textShadows; + exports.textTransform = textTransform; + exports.top = top; + exports.transform = transform; + exports.transforms = transforms; + exports.transformOrigin = transformOrigin; + exports.transformOrigin3d = transformOrigin3d; + exports.transitionDelay = transitionDelay; + exports.transitionDuration = transitionDuration; + exports.transitionProperty = transitionProperty; + exports.transformStyle = transformStyle; + exports.transitionTimingFunction = transitionTimingFunction; + exports.userSelect = userSelect; + exports.verticalAlign = verticalAlign; + exports.visibility = visibility; + exports.width = width; + exports.whiteSpace = whiteSpace; + exports.wordBreak = wordBreak; + exports.wordSpacing = wordSpacing; + exports.wordWrap = wordWrap; + exports.zIndex = zIndex; + exports.selector = selector; + exports.media = media; + exports.active = active; + exports.checked = checked; + exports.$$default = $$default; + exports.default = $$default; + exports.__esModule = true; + exports.defined = defined; + exports.disabled = disabled; + exports.empty = empty; + exports.enabled = enabled; + exports.first = first; + exports.firstChild = firstChild; + exports.firstOfType = firstOfType; + exports.focus = focus; + exports.focusVisible = focusVisible; + exports.focusWithin = focusWithin; + exports.host = host; + exports.hover = hover; + exports.indeterminate = indeterminate; + exports.inRange = inRange; + exports.invalid = invalid; + exports.lang = lang; + exports.lastChild = lastChild; + exports.lastOfType = lastOfType; + exports.link = link; + exports.not_ = not_; + exports.Nth = Nth; + exports.nthChild = nthChild; + exports.nthLastChild = nthLastChild; + exports.nthLastOfType = nthLastOfType; + exports.nthOfType = nthOfType; + exports.onlyChild = onlyChild; + exports.onlyOfType = onlyOfType; + exports.optional = optional; + exports.outOfRange = outOfRange; + exports.readOnly = readOnly; + exports.readWrite = readWrite; + exports.required = required; + exports.root = root; + exports.scope = scope; + exports.target = target; + exports.valid = valid; + exports.visited = visited; + exports.after = after; + exports.before = before; + exports.firstLetter = firstLetter; + exports.firstLine = firstLine; + exports.placeholder = placeholder; + exports.selection = selection; + exports.child = child; + exports.children = children; + exports.directSibling = directSibling; + exports.siblings = siblings; + exports.anyLink = anyLink; + exports.initial = initial; + exports.inherit_ = inherit_; + exports.unset = unset; + exports.$$var = $$var; + exports.varDefault = varDefault; + exports.auto = auto; + exports.none = none; + exports.text = text; + exports.pct = pct; + exports.ch = ch; + exports.cm = cm; + exports.em = em; + exports.ex = ex; + exports.mm = mm; + exports.pt = pt; + exports.px = px; + exports.pxFloat = pxFloat; + exports.rem = rem; + exports.vh = vh; + exports.vmin = vmin; + exports.vmax = vmax; + exports.zero = zero; + exports.deg = deg; + exports.rad = rad; + exports.grad = grad; + exports.turn = turn; + exports.ltr = ltr; + exports.rtl = rtl; + exports.absolute = absolute; + exports.relative = relative; + exports.$$static = $$static; + exports.fixed = fixed; + exports.sticky = sticky; + exports.isolate = isolate; + exports.horizontal = horizontal; + exports.vertical = vertical; + exports.smallCaps = smallCaps; + exports.italic = italic; + exports.oblique = oblique; + exports.hidden = hidden; + exports.visible = visible; + exports.scroll = scroll; + exports.rgb = rgb; + exports.rgba = rgba; + exports.hsl = hsl; + exports.hsla = hsla; + exports.hex = hex; + exports.currentColor = currentColor; + exports.local = local; + exports.paddingBox = paddingBox; + exports.borderBox = borderBox; + exports.contentBox = contentBox; + exports.noRepeat = noRepeat; + exports.space = space; + exports.repeat = repeat; + exports.minmax = minmax; + exports.repeatX = repeatX; + exports.repeatY = repeatY; + exports.contain = contain; + exports.cover = cover; + exports.row = row; + exports.rowReverse = rowReverse; + exports.column = column; + exports.columnReverse = columnReverse; + exports.wrap = wrap; + exports.nowrap = nowrap; + exports.wrapReverse = wrapReverse; + exports.inline = inline; + exports.block = block; + exports.contents = contents; + exports.flexBox = flexBox; + exports.grid = grid; + exports.inlineBlock = inlineBlock; + exports.inlineFlex = inlineFlex; + exports.inlineGrid = inlineGrid; + exports.inlineTable = inlineTable; + exports.listItem = listItem; + exports.runIn = runIn; + exports.table = table; + exports.tableCaption = tableCaption; + exports.tableColumnGroup = tableColumnGroup; + exports.tableHeaderGroup = tableHeaderGroup; + exports.tableFooterGroup = tableFooterGroup; + exports.tableRowGroup = tableRowGroup; + exports.tableCell = tableCell; + exports.tableColumn = tableColumn; + exports.tableRow = tableRow; + exports.flexStart = flexStart; + exports.flexEnd = flexEnd; + exports.center = center; + exports.stretch = stretch; + exports.spaceBetween = spaceBetween; + exports.spaceAround = spaceAround; + exports.spaceEvenly = spaceEvenly; + exports.baseline = baseline; + exports.forwards = forwards; + exports.backwards = backwards; + exports.both = both; + exports.infinite = infinite; + exports.count = count; + exports.paused = paused; + exports.running = running; + exports.inside = inside; + exports.outside = outside; + exports.solid = solid; + exports.dotted = dotted; + exports.dashed = dashed; + exports.underline = underline; + exports.overline = overline; + exports.lineThrough = lineThrough; + exports.clip = clip; + exports.ellipsis = ellipsis; + exports.wavy = wavy; + exports.$$double = $$double; + exports.uppercase = uppercase; + exports.lowercase = lowercase; + exports.capitalize = capitalize; + exports.sub = sub; + exports.$$super = $$super; + exports.textTop = textTop; + exports.textBottom = textBottom; + exports.middle = middle; + exports.normal = normal; + exports.breakAll = breakAll; + exports.keepAll = keepAll; + exports.breakWord = breakWord; + exports.reverse = reverse; + exports.alternate = alternate; + exports.alternateReverse = alternateReverse; + exports.fill = fill; + exports.content = content; + exports.maxContent = maxContent; + exports.minContent = minContent; + exports.fitContent = fitContent; + exports.all = all; + exports.round = round; + exports.miter = miter; + exports.bevel = bevel; + exports.butt = butt; + exports.square = square; + exports.panX = panX; + exports.panY = panY; + exports.panLeft = panLeft; + exports.panRight = panRight; + exports.panUp = panUp; + exports.panDown = panDown; + exports.pinchZoom = pinchZoom; + exports.manipulation = manipulation; + exports.thin = thin; + exports.extraLight = extraLight; + exports.light = light; + exports.medium = medium; + exports.semiBold = semiBold; + exports.bold = bold; + exports.extraBold = extraBold; + exports.lighter = lighter; + exports.bolder = bolder; + exports.fr = fr; + exports.vw = vw; + exports.localUrl = localUrl; + exports.url = url; + exports.linear = linear; + exports.ease = ease; + exports.easeIn = easeIn; + exports.easeOut = easeOut; + exports.easeInOut = easeInOut; + exports.stepStart = stepStart; + exports.stepEnd = stepEnd; + exports.steps = steps; + exports.cubicBezier = cubicBezier; + exports.marginBox = marginBox; + exports.fillBox = fillBox; + exports.strokeBox = strokeBox; + exports.viewBox = viewBox; + exports.translate = translate; + exports.translate3d = translate3d; + exports.translateX = translateX; + exports.translateY = translateY; + exports.translateZ = translateZ; + exports.scale = scale; + exports.scale3d = scale3d; + exports.scaleX = scaleX; + exports.scaleY = scaleY; + exports.scaleZ = scaleZ; + exports.rotate = rotate; + exports.rotate3d = rotate3d; + exports.rotateX = rotateX; + exports.rotateY = rotateY; + exports.rotateZ = rotateZ; + exports.skew = skew; + exports.skewX = skewX; + exports.skewY = skewY; + exports.linearGradient = linearGradient; + exports.repeatingLinearGradient = repeatingLinearGradient; + exports.radialGradient = radialGradient; + exports.repeatingRadialGradient = repeatingRadialGradient; + exports.conicGradient = conicGradient; + exports.areas = areas; + exports.ident = ident; + exports.numIdent = numIdent; + exports.contextMenu = contextMenu; + exports.help = help; + exports.pointer = pointer; + exports.progress = progress; + exports.wait = wait; + exports.cell = cell; + exports.crosshair = crosshair; + exports.verticalText = verticalText; + exports.alias = alias; + exports.copy = copy; + exports.move = move; + exports.noDrop = noDrop; + exports.notAllowed = notAllowed; + exports.grab = grab; + exports.grabbing = grabbing; + exports.allScroll = allScroll; + exports.colResize = colResize; + exports.rowResize = rowResize; + exports.nResize = nResize; + exports.eResize = eResize; + exports.sResize = sResize; + exports.wResize = wResize; + exports.neResize = neResize; + exports.nwResize = nwResize; + exports.seResize = seResize; + exports.swResize = swResize; + exports.ewResize = ewResize; + exports.nsResize = nsResize; + exports.neswResize = neswResize; + exports.nwseResize = nwseResize; + exports.zoomIn = zoomIn; + exports.zoomOut = zoomOut; + exports.flex3 = flex3; + exports.border = border; + exports.borderTop = borderTop; + exports.backgroundSize = backgroundSize; + exports.textDecoration = textDecoration; + exports.background = background; + exports.backgrounds = backgrounds; + exports.gridAutoColumns = gridAutoColumns; + exports.gridAutoRows = gridAutoRows; + exports.gridTemplateColumns = gridTemplateColumns; + exports.gridTemplateRows = gridTemplateRows; + exports.Calc = Calc; + exports.size = size; + exports.filter = filter; + exports.Transition = Transition; + exports.transitionValue = transitionValue; + exports.transitionList = transitionList; + exports.transition = transition; + exports.transitions = transitions; + exports.Animation = Animation; + exports.animationValue = animationValue; + exports.animation = animation; + exports.animations = animations; + exports.animationName = animationName; + exports.SVG = SVG; + exports.touchAction = touchAction; + exports.aliceblue = aliceblue; + exports.antiquewhite = antiquewhite; + exports.aqua = aqua; + exports.aquamarine = aquamarine; + exports.azure = azure; + exports.beige = beige; + exports.bisque = bisque; + exports.black = black; + exports.blanchedalmond = blanchedalmond; + exports.blue = blue; + exports.blueviolet = blueviolet; + exports.brown = brown; + exports.burlywood = burlywood; + exports.cadetblue = cadetblue; + exports.chartreuse = chartreuse; + exports.chocolate = chocolate; + exports.coral = coral; + exports.cornflowerblue = cornflowerblue; + exports.cornsilk = cornsilk; + exports.crimson = crimson; + exports.cyan = cyan; + exports.darkblue = darkblue; + exports.darkcyan = darkcyan; + exports.darkgoldenrod = darkgoldenrod; + exports.darkgray = darkgray; + exports.darkgreen = darkgreen; + exports.darkgrey = darkgrey; + exports.darkkhaki = darkkhaki; + exports.darkmagenta = darkmagenta; + exports.darkolivegreen = darkolivegreen; + exports.darkorange = darkorange; + exports.darkorchid = darkorchid; + exports.darkred = darkred; + exports.darksalmon = darksalmon; + exports.darkseagreen = darkseagreen; + exports.darkslateblue = darkslateblue; + exports.darkslategray = darkslategray; + exports.darkslategrey = darkslategrey; + exports.darkturquoise = darkturquoise; + exports.darkviolet = darkviolet; + exports.deeppink = deeppink; + exports.deepskyblue = deepskyblue; + exports.dimgray = dimgray; + exports.dimgrey = dimgrey; + exports.dodgerblue = dodgerblue; + exports.firebrick = firebrick; + exports.floralwhite = floralwhite; + exports.forestgreen = forestgreen; + exports.fuchsia = fuchsia; + exports.gainsboro = gainsboro; + exports.ghostwhite = ghostwhite; + exports.gold = gold; + exports.goldenrod = goldenrod; + exports.gray = gray; + exports.green = green; + exports.greenyellow = greenyellow; + exports.grey = grey; + exports.honeydew = honeydew; + exports.hotpink = hotpink; + exports.indianred = indianred; + exports.indigo = indigo; + exports.ivory = ivory; + exports.khaki = khaki; + exports.lavender = lavender; + exports.lavenderblush = lavenderblush; + exports.lawngreen = lawngreen; + exports.lemonchiffon = lemonchiffon; + exports.lightblue = lightblue; + exports.lightcoral = lightcoral; + exports.lightcyan = lightcyan; + exports.lightgoldenrodyellow = lightgoldenrodyellow; + exports.lightgray = lightgray; + exports.lightgreen = lightgreen; + exports.lightgrey = lightgrey; + exports.lightpink = lightpink; + exports.lightsalmon = lightsalmon; + exports.lightseagreen = lightseagreen; + exports.lightskyblue = lightskyblue; + exports.lightslategray = lightslategray; + exports.lightslategrey = lightslategrey; + exports.lightsteelblue = lightsteelblue; + exports.lightyellow = lightyellow; + exports.lime = lime; + exports.limegreen = limegreen; + exports.linen = linen; + exports.magenta = magenta; + exports.maroon = maroon; + exports.mediumaquamarine = mediumaquamarine; + exports.mediumblue = mediumblue; + exports.mediumorchid = mediumorchid; + exports.mediumpurple = mediumpurple; + exports.mediumseagreen = mediumseagreen; + exports.mediumslateblue = mediumslateblue; + exports.mediumspringgreen = mediumspringgreen; + exports.mediumturquoise = mediumturquoise; + exports.mediumvioletred = mediumvioletred; + exports.midnightblue = midnightblue; + exports.mintcream = mintcream; + exports.mistyrose = mistyrose; + exports.moccasin = moccasin; + exports.navajowhite = navajowhite; + exports.navy = navy; + exports.oldlace = oldlace; + exports.olive = olive; + exports.olivedrab = olivedrab; + exports.orange = orange; + exports.orangered = orangered; + exports.orchid = orchid; + exports.palegoldenrod = palegoldenrod; + exports.palegreen = palegreen; + exports.paleturquoise = paleturquoise; + exports.palevioletred = palevioletred; + exports.papayawhip = papayawhip; + exports.peachpuff = peachpuff; + exports.peru = peru; + exports.pink = pink; + exports.plum = plum; + exports.powderblue = powderblue; + exports.purple = purple; + exports.rebeccapurple = rebeccapurple; + exports.red = red; + exports.rosybrown = rosybrown; + exports.royalblue = royalblue; + exports.saddlebrown = saddlebrown; + exports.salmon = salmon; + exports.sandybrown = sandybrown; + exports.seagreen = seagreen; + exports.seashell = seashell; + exports.sienna = sienna; + exports.silver = silver; + exports.skyblue = skyblue; + exports.slateblue = slateblue; + exports.slategray = slategray; + exports.slategrey = slategrey; + exports.snow = snow; + exports.springgreen = springgreen; + exports.steelblue = steelblue; + exports.tan = tan; + exports.teal = teal; + exports.thistle = thistle; + exports.tomato = tomato; + exports.turquoise = turquoise; + exports.violet = violet; + exports.wheat = wheat; + exports.white = white; + exports.whitesmoke = whitesmoke; + exports.yellow = yellow; + exports.yellowgreen = yellowgreen; + exports.transparent = transparent; + exports.insertRule = insertRule; + exports.renderRule = renderRule; + exports.$$global = $$global; + exports.renderGlobal = renderGlobal; + exports.style = style; + exports.merge = merge; + exports.merge2 = merge2; + exports.merge3 = merge3; + exports.merge4 = merge4; + exports.keyframes = keyframes; + exports.renderKeyframes = renderKeyframes$1; + exports.fontFace = fontFace; + }); + + // node_modules/react/cjs/react.development.js + var require_react_development = __commonJS((exports, module) => { + /** + * @license React + * react.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + "use strict"; + if (true) { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var ReactVersion = "18.2.0"; + var REACT_ELEMENT_TYPE = Symbol.for("react.element"); + var REACT_PORTAL_TYPE = Symbol.for("react.portal"); + var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"); + var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"); + var REACT_PROFILER_TYPE = Symbol.for("react.profiler"); + var REACT_PROVIDER_TYPE = Symbol.for("react.provider"); + var REACT_CONTEXT_TYPE = Symbol.for("react.context"); + var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"); + var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"); + var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"); + var REACT_MEMO_TYPE = Symbol.for("react.memo"); + var REACT_LAZY_TYPE = Symbol.for("react.lazy"); + var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"); + var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = "@@iterator"; + function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== "object") { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === "function") { + return maybeIterator; + } + return null; + } + var ReactCurrentDispatcher = { + current: null + }; + var ReactCurrentBatchConfig = { + transition: null + }; + var ReactCurrentActQueue = { + current: null, + isBatchingLegacy: false, + didScheduleLegacyUpdate: false + }; + var ReactCurrentOwner = { + current: null + }; + var ReactDebugCurrentFrame = {}; + var currentExtraStackFrame = null; + function setExtraStackFrame(stack) { + { + currentExtraStackFrame = stack; + } + } + { + ReactDebugCurrentFrame.setExtraStackFrame = function(stack) { + { + currentExtraStackFrame = stack; + } + }; + ReactDebugCurrentFrame.getCurrentStack = null; + ReactDebugCurrentFrame.getStackAddendum = function() { + var stack = ""; + if (currentExtraStackFrame) { + stack += currentExtraStackFrame; + } + var impl = ReactDebugCurrentFrame.getCurrentStack; + if (impl) { + stack += impl() || ""; + } + return stack; + }; + } + var enableScopeAPI = false; + var enableCacheElement = false; + var enableTransitionTracing = false; + var enableLegacyHidden = false; + var enableDebugTracing = false; + var ReactSharedInternals = { + ReactCurrentDispatcher, + ReactCurrentBatchConfig, + ReactCurrentOwner + }; + { + ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame; + ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue; + } + function warn(format) { + { + { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + printWarning("warn", format, args); + } + } + } + function error(format) { + { + { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + } + } + function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame2.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([stack]); + } + var argsWithFormat = args.map(function(item) { + return String(item); + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + } + var didWarnStateUpdateForUnmountedComponent = {}; + function warnNoop(publicInstance, callerName) { + { + var _constructor = publicInstance.constructor; + var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass"; + var warningKey = componentName + "." + callerName; + if (didWarnStateUpdateForUnmountedComponent[warningKey]) { + return; + } + error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, componentName); + didWarnStateUpdateForUnmountedComponent[warningKey] = true; + } + } + var ReactNoopUpdateQueue = { + isMounted: function(publicInstance) { + return false; + }, + enqueueForceUpdate: function(publicInstance, callback, callerName) { + warnNoop(publicInstance, "forceUpdate"); + }, + enqueueReplaceState: function(publicInstance, completeState, callback, callerName) { + warnNoop(publicInstance, "replaceState"); + }, + enqueueSetState: function(publicInstance, partialState, callback, callerName) { + warnNoop(publicInstance, "setState"); + } + }; + var assign = Object.assign; + var emptyObject = {}; + { + Object.freeze(emptyObject); + } + function Component(props, context, updater) { + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + } + Component.prototype.isReactComponent = {}; + Component.prototype.setState = function(partialState, callback) { + if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null) { + throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); + } + this.updater.enqueueSetState(this, partialState, callback, "setState"); + }; + Component.prototype.forceUpdate = function(callback) { + this.updater.enqueueForceUpdate(this, callback, "forceUpdate"); + }; + { + var deprecatedAPIs = { + isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."], + replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."] + }; + var defineDeprecationWarning = function(methodName, info) { + Object.defineProperty(Component.prototype, methodName, { + get: function() { + warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]); + return void 0; + } + }); + }; + for (var fnName in deprecatedAPIs) { + if (deprecatedAPIs.hasOwnProperty(fnName)) { + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + } + } + function ComponentDummy() { + } + ComponentDummy.prototype = Component.prototype; + function PureComponent(props, context, updater) { + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + } + var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); + pureComponentPrototype.constructor = PureComponent; + assign(pureComponentPrototype, Component.prototype); + pureComponentPrototype.isPureReactComponent = true; + function createRef() { + var refObject = { + current: null + }; + { + Object.seal(refObject); + } + return refObject; + } + var isArrayImpl = Array.isArray; + function isArray(a) { + return isArrayImpl(a); + } + function typeName(value) { + { + var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; + return type; + } + } + function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } + } + function testStringCoercion(value) { + return "" + value; + } + function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + if (displayName) { + return displayName; + } + var functionName = innerType.displayName || innerType.name || ""; + return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName; + } + function getContextName(type) { + return type.displayName || "Context"; + } + function getComponentNameFromType(type) { + if (type == null) { + return null; + } + { + if (typeof type.tag === "number") { + error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."); + } + } + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + switch (type) { + case REACT_FRAGMENT_TYPE: + return "Fragment"; + case REACT_PORTAL_TYPE: + return "Portal"; + case REACT_PROFILER_TYPE: + return "Profiler"; + case REACT_STRICT_MODE_TYPE: + return "StrictMode"; + case REACT_SUSPENSE_TYPE: + return "Suspense"; + case REACT_SUSPENSE_LIST_TYPE: + return "SuspenseList"; + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + ".Consumer"; + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + ".Provider"; + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, "ForwardRef"); + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + if (outerName !== null) { + return outerName; + } + return getComponentNameFromType(type.type) || "Memo"; + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + } + } + return null; + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true + }; + var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs; + { + didWarnAboutStringRefs = {}; + } + function hasValidRef(config) { + { + if (hasOwnProperty.call(config, "ref")) { + var getter = Object.getOwnPropertyDescriptor(config, "ref").get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.ref !== void 0; + } + function hasValidKey(config) { + { + if (hasOwnProperty.call(config, "key")) { + var getter = Object.getOwnPropertyDescriptor(config, "key").get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.key !== void 0; + } + function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function() { + { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName); + } + } + }; + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, "key", { + get: warnAboutAccessingKey, + configurable: true + }); + } + function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function() { + { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName); + } + } + }; + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, "ref", { + get: warnAboutAccessingRef, + configurable: true + }); + } + function warnIfStringRefCannotBeAutoConverted(config) { + { + if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) { + var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref); + didWarnAboutStringRefs[componentName] = true; + } + } + } + } + var ReactElement = function(type, key, ref, self2, source, owner, props) { + var element = { + $$typeof: REACT_ELEMENT_TYPE, + type, + key, + ref, + props, + _owner: owner + }; + { + element._store = {}; + Object.defineProperty(element._store, "validated", { + configurable: false, + enumerable: false, + writable: true, + value: false + }); + Object.defineProperty(element, "_self", { + configurable: false, + enumerable: false, + writable: false, + value: self2 + }); + Object.defineProperty(element, "_source", { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + return element; + }; + function createElement(type, config, children) { + var propName; + var props = {}; + var key = null; + var ref = null; + var self2 = null; + var source = null; + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + { + warnIfStringRefCannotBeAutoConverted(config); + } + } + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + key = "" + config.key; + } + self2 = config.__self === void 0 ? null : config.__self; + source = config.__source === void 0 ? null : config.__source; + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } + } + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + { + if (Object.freeze) { + Object.freeze(childArray); + } + } + props.children = childArray; + } + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + for (propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } + { + if (key || ref) { + var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type; + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + } + return ReactElement(type, key, ref, self2, source, ReactCurrentOwner.current, props); + } + function cloneAndReplaceKey(oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + return newElement; + } + function cloneElement(element, config, children) { + if (element === null || element === void 0) { + throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + "."); + } + var propName; + var props = assign({}, element.props); + var key = element.key; + var ref = element.ref; + var self2 = element._self; + var source = element._source; + var owner = element._owner; + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + owner = ReactCurrentOwner.current; + } + if (hasValidKey(config)) { + { + checkKeyStringCoercion(config.key); + } + key = "" + config.key; + } + var defaultProps; + if (element.type && element.type.defaultProps) { + defaultProps = element.type.defaultProps; + } + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + if (config[propName] === void 0 && defaultProps !== void 0) { + props[propName] = defaultProps[propName]; + } else { + props[propName] = config[propName]; + } + } + } + } + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + props.children = childArray; + } + return ReactElement(element.type, key, ref, self2, source, owner, props); + } + function isValidElement(object) { + return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + } + var SEPARATOR = "."; + var SUBSEPARATOR = ":"; + function escape(key) { + var escapeRegex = /[=:]/g; + var escaperLookup = { + "=": "=0", + ":": "=2" + }; + var escapedString = key.replace(escapeRegex, function(match) { + return escaperLookup[match]; + }); + return "$" + escapedString; + } + var didWarnAboutMaps = false; + var userProvidedKeyEscapeRegex = /\/+/g; + function escapeUserProvidedKey(text) { + return text.replace(userProvidedKeyEscapeRegex, "$&/"); + } + function getElementKey(element, index) { + if (typeof element === "object" && element !== null && element.key != null) { + { + checkKeyStringCoercion(element.key); + } + return escape("" + element.key); + } + return index.toString(36); + } + function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { + var type = typeof children; + if (type === "undefined" || type === "boolean") { + children = null; + } + var invokeCallback = false; + if (children === null) { + invokeCallback = true; + } else { + switch (type) { + case "string": + case "number": + invokeCallback = true; + break; + case "object": + switch (children.$$typeof) { + case REACT_ELEMENT_TYPE: + case REACT_PORTAL_TYPE: + invokeCallback = true; + } + } + } + if (invokeCallback) { + var _child = children; + var mappedChild = callback(_child); + var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar; + if (isArray(mappedChild)) { + var escapedChildKey = ""; + if (childKey != null) { + escapedChildKey = escapeUserProvidedKey(childKey) + "/"; + } + mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) { + return c; + }); + } else if (mappedChild != null) { + if (isValidElement(mappedChild)) { + { + if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) { + checkKeyStringCoercion(mappedChild.key); + } + } + mappedChild = cloneAndReplaceKey(mappedChild, escapedPrefix + (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey); + } + array.push(mappedChild); + } + return 1; + } + var child; + var nextName; + var subtreeCount = 0; + var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR; + if (isArray(children)) { + for (var i = 0; i < children.length; i++) { + child = children[i]; + nextName = nextNamePrefix + getElementKey(child, i); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else { + var iteratorFn = getIteratorFn(children); + if (typeof iteratorFn === "function") { + var iterableChildren = children; + { + if (iteratorFn === iterableChildren.entries) { + if (!didWarnAboutMaps) { + warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."); + } + didWarnAboutMaps = true; + } + } + var iterator = iteratorFn.call(iterableChildren); + var step; + var ii = 0; + while (!(step = iterator.next()).done) { + child = step.value; + nextName = nextNamePrefix + getElementKey(child, ii++); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else if (type === "object") { + var childrenString = String(children); + throw new Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead."); + } + } + return subtreeCount; + } + function mapChildren(children, func, context) { + if (children == null) { + return children; + } + var result = []; + var count = 0; + mapIntoArray(children, result, "", "", function(child) { + return func.call(context, child, count++); + }); + return result; + } + function countChildren(children) { + var n = 0; + mapChildren(children, function() { + n++; + }); + return n; + } + function forEachChildren(children, forEachFunc, forEachContext) { + mapChildren(children, function() { + forEachFunc.apply(this, arguments); + }, forEachContext); + } + function toArray(children) { + return mapChildren(children, function(child) { + return child; + }) || []; + } + function onlyChild(children) { + if (!isValidElement(children)) { + throw new Error("React.Children.only expected to receive a single React element child."); + } + return children; + } + function createContext(defaultValue) { + var context = { + $$typeof: REACT_CONTEXT_TYPE, + _currentValue: defaultValue, + _currentValue2: defaultValue, + _threadCount: 0, + Provider: null, + Consumer: null, + _defaultValue: null, + _globalName: null + }; + context.Provider = { + $$typeof: REACT_PROVIDER_TYPE, + _context: context + }; + var hasWarnedAboutUsingNestedContextConsumers = false; + var hasWarnedAboutUsingConsumerProvider = false; + var hasWarnedAboutDisplayNameOnConsumer = false; + { + var Consumer = { + $$typeof: REACT_CONTEXT_TYPE, + _context: context + }; + Object.defineProperties(Consumer, { + Provider: { + get: function() { + if (!hasWarnedAboutUsingConsumerProvider) { + hasWarnedAboutUsingConsumerProvider = true; + error("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?"); + } + return context.Provider; + }, + set: function(_Provider) { + context.Provider = _Provider; + } + }, + _currentValue: { + get: function() { + return context._currentValue; + }, + set: function(_currentValue) { + context._currentValue = _currentValue; + } + }, + _currentValue2: { + get: function() { + return context._currentValue2; + }, + set: function(_currentValue2) { + context._currentValue2 = _currentValue2; + } + }, + _threadCount: { + get: function() { + return context._threadCount; + }, + set: function(_threadCount) { + context._threadCount = _threadCount; + } + }, + Consumer: { + get: function() { + if (!hasWarnedAboutUsingNestedContextConsumers) { + hasWarnedAboutUsingNestedContextConsumers = true; + error("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?"); + } + return context.Consumer; + } + }, + displayName: { + get: function() { + return context.displayName; + }, + set: function(displayName) { + if (!hasWarnedAboutDisplayNameOnConsumer) { + warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName); + hasWarnedAboutDisplayNameOnConsumer = true; + } + } + } + }); + context.Consumer = Consumer; + } + { + context._currentRenderer = null; + context._currentRenderer2 = null; + } + return context; + } + var Uninitialized = -1; + var Pending = 0; + var Resolved = 1; + var Rejected = 2; + function lazyInitializer(payload) { + if (payload._status === Uninitialized) { + var ctor = payload._result; + var thenable = ctor(); + thenable.then(function(moduleObject2) { + if (payload._status === Pending || payload._status === Uninitialized) { + var resolved = payload; + resolved._status = Resolved; + resolved._result = moduleObject2; + } + }, function(error2) { + if (payload._status === Pending || payload._status === Uninitialized) { + var rejected = payload; + rejected._status = Rejected; + rejected._result = error2; + } + }); + if (payload._status === Uninitialized) { + var pending = payload; + pending._status = Pending; + pending._result = thenable; + } + } + if (payload._status === Resolved) { + var moduleObject = payload._result; + { + if (moduleObject === void 0) { + error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", moduleObject); + } + } + { + if (!("default" in moduleObject)) { + error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", moduleObject); + } + } + return moduleObject.default; + } else { + throw payload._result; + } + } + function lazy(ctor) { + var payload = { + _status: Uninitialized, + _result: ctor + }; + var lazyType = { + $$typeof: REACT_LAZY_TYPE, + _payload: payload, + _init: lazyInitializer + }; + { + var defaultProps; + var propTypes; + Object.defineProperties(lazyType, { + defaultProps: { + configurable: true, + get: function() { + return defaultProps; + }, + set: function(newDefaultProps) { + error("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."); + defaultProps = newDefaultProps; + Object.defineProperty(lazyType, "defaultProps", { + enumerable: true + }); + } + }, + propTypes: { + configurable: true, + get: function() { + return propTypes; + }, + set: function(newPropTypes) { + error("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."); + propTypes = newPropTypes; + Object.defineProperty(lazyType, "propTypes", { + enumerable: true + }); + } + } + }); + } + return lazyType; + } + function forwardRef(render) { + { + if (render != null && render.$$typeof === REACT_MEMO_TYPE) { + error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."); + } else if (typeof render !== "function") { + error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render); + } else { + if (render.length !== 0 && render.length !== 2) { + error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."); + } + } + if (render != null) { + if (render.defaultProps != null || render.propTypes != null) { + error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?"); + } + } + } + var elementType = { + $$typeof: REACT_FORWARD_REF_TYPE, + render + }; + { + var ownName; + Object.defineProperty(elementType, "displayName", { + enumerable: false, + configurable: true, + get: function() { + return ownName; + }, + set: function(name) { + ownName = name; + if (!render.name && !render.displayName) { + render.displayName = name; + } + } + }); + } + return elementType; + } + var REACT_MODULE_REFERENCE; + { + REACT_MODULE_REFERENCE = Symbol.for("react.module.reference"); + } + function isValidElementType(type) { + if (typeof type === "string" || typeof type === "function") { + return true; + } + if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) { + return true; + } + if (typeof type === "object" && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) { + return true; + } + } + return false; + } + function memo(type, compare) { + { + if (!isValidElementType(type)) { + error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type); + } + } + var elementType = { + $$typeof: REACT_MEMO_TYPE, + type, + compare: compare === void 0 ? null : compare + }; + { + var ownName; + Object.defineProperty(elementType, "displayName", { + enumerable: false, + configurable: true, + get: function() { + return ownName; + }, + set: function(name) { + ownName = name; + if (!type.name && !type.displayName) { + type.displayName = name; + } + } + }); + } + return elementType; + } + function resolveDispatcher() { + var dispatcher = ReactCurrentDispatcher.current; + { + if (dispatcher === null) { + error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."); + } + } + return dispatcher; + } + function useContext(Context) { + var dispatcher = resolveDispatcher(); + { + if (Context._context !== void 0) { + var realContext = Context._context; + if (realContext.Consumer === Context) { + error("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?"); + } else if (realContext.Provider === Context) { + error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?"); + } + } + } + return dispatcher.useContext(Context); + } + function useState(initialState) { + var dispatcher = resolveDispatcher(); + return dispatcher.useState(initialState); + } + function useReducer(reducer, initialArg, init) { + var dispatcher = resolveDispatcher(); + return dispatcher.useReducer(reducer, initialArg, init); + } + function useRef(initialValue) { + var dispatcher = resolveDispatcher(); + return dispatcher.useRef(initialValue); + } + function useEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useEffect(create, deps); + } + function useInsertionEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useInsertionEffect(create, deps); + } + function useLayoutEffect(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useLayoutEffect(create, deps); + } + function useCallback(callback, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useCallback(callback, deps); + } + function useMemo(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useMemo(create, deps); + } + function useImperativeHandle(ref, create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useImperativeHandle(ref, create, deps); + } + function useDebugValue(value, formatterFn) { + { + var dispatcher = resolveDispatcher(); + return dispatcher.useDebugValue(value, formatterFn); + } + } + function useTransition() { + var dispatcher = resolveDispatcher(); + return dispatcher.useTransition(); + } + function useDeferredValue(value) { + var dispatcher = resolveDispatcher(); + return dispatcher.useDeferredValue(value); + } + function useId() { + var dispatcher = resolveDispatcher(); + return dispatcher.useId(); + } + function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { + var dispatcher = resolveDispatcher(); + return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); + } + var disabledDepth = 0; + var prevLog; + var prevInfo; + var prevWarn; + var prevError; + var prevGroup; + var prevGroupCollapsed; + var prevGroupEnd; + function disabledLog() { + } + disabledLog.__reactDisabledLog = true; + function disableLogs() { + { + if (disabledDepth === 0) { + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + } + disabledDepth++; + } + } + function reenableLogs() { + { + disabledDepth--; + if (disabledDepth === 0) { + var props = { + configurable: true, + enumerable: true, + writable: true + }; + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + } + if (disabledDepth < 0) { + error("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + } + var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher; + var prefix; + function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === void 0) { + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ""; + } + } + return "\n" + prefix + name; + } + } + var reentry = false; + var componentFrameCache; + { + var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); + } + function describeNativeComponentFrame(fn, construct) { + if (!fn || reentry) { + return ""; + } + { + var frame = componentFrameCache.get(fn); + if (frame !== void 0) { + return frame; + } + } + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var previousDispatcher; + { + previousDispatcher = ReactCurrentDispatcher$1.current; + ReactCurrentDispatcher$1.current = null; + disableLogs(); + } + try { + if (construct) { + var Fake = function() { + throw Error(); + }; + Object.defineProperty(Fake.prototype, "props", { + set: function() { + throw Error(); + } + }); + if (typeof Reflect === "object" && Reflect.construct) { + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + fn(); + } + } catch (sample) { + if (sample && control && typeof sample.stack === "string") { + var sampleLines = sample.stack.split("\n"); + var controlLines = control.stack.split("\n"); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + c--; + } + for (; s >= 1 && c >= 0; s--, c--) { + if (sampleLines[s] !== controlLines[c]) { + if (s !== 1 || c !== 1) { + do { + s--; + c--; + if (c < 0 || sampleLines[s] !== controlLines[c]) { + var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); + if (fn.displayName && _frame.includes("")) { + _frame = _frame.replace("", fn.displayName); + } + { + if (typeof fn === "function") { + componentFrameCache.set(fn, _frame); + } + } + return _frame; + } + } while (s >= 1 && c >= 0); + } + break; + } + } + } + } finally { + reentry = false; + { + ReactCurrentDispatcher$1.current = previousDispatcher; + reenableLogs(); + } + Error.prepareStackTrace = previousPrepareStackTrace; + } + var name = fn ? fn.displayName || fn.name : ""; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ""; + { + if (typeof fn === "function") { + componentFrameCache.set(fn, syntheticFrame); + } + } + return syntheticFrame; + } + function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + } + function shouldConstruct(Component2) { + var prototype = Component2.prototype; + return !!(prototype && prototype.isReactComponent); + } + function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + if (type == null) { + return ""; + } + if (typeof type === "function") { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + if (typeof type === "string") { + return describeBuiltInComponentFrame(type); + } + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame("Suspense"); + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame("SuspenseList"); + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + case REACT_MEMO_TYPE: + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) { + } + } + } + } + return ""; + } + var loggedTypeFailures = {}; + var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } + } + function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + var has = Function.call.bind(hasOwnProperty); + for (var typeSpecName in typeSpecs) { + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; + try { + if (typeof typeSpecs[typeSpecName] !== "function") { + var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."); + err.name = "Invariant Violation"; + throw err; + } + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"); + } catch (ex) { + error$1 = ex; + } + if (error$1 && !(error$1 instanceof Error)) { + setCurrentlyValidatingElement(element); + error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1); + setCurrentlyValidatingElement(null); + } + if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + error("Failed %s type: %s", location, error$1.message); + setCurrentlyValidatingElement(null); + } + } + } + } + } + function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + setExtraStackFrame(stack); + } else { + setExtraStackFrame(null); + } + } + } + var propTypesMisspellWarningShown; + { + propTypesMisspellWarningShown = false; + } + function getDeclarationErrorAddendum() { + if (ReactCurrentOwner.current) { + var name = getComponentNameFromType(ReactCurrentOwner.current.type); + if (name) { + return "\n\nCheck the render method of `" + name + "`."; + } + } + return ""; + } + function getSourceInfoErrorAddendum(source) { + if (source !== void 0) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ""); + var lineNumber = source.lineNumber; + return "\n\nCheck your code at " + fileName + ":" + lineNumber + "."; + } + return ""; + } + function getSourceInfoErrorAddendumForProps(elementProps) { + if (elementProps !== null && elementProps !== void 0) { + return getSourceInfoErrorAddendum(elementProps.__source); + } + return ""; + } + var ownerHasKeyUseWarning = {}; + function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + if (!info) { + var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name; + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + return info; + } + function validateExplicitKey(element, parentType) { + if (!element._store || element._store.validated || element.key != null) { + return; + } + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; + var childOwner = ""; + if (element && element._owner && element._owner !== ReactCurrentOwner.current) { + childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; + } + { + setCurrentlyValidatingElement$1(element); + error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + setCurrentlyValidatingElement$1(null); + } + } + function validateChildKeys(node, parentType) { + if (typeof node !== "object") { + return; + } + if (isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + if (typeof iteratorFn === "function") { + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + while (!(step = iterator.next()).done) { + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + } + function validatePropTypes(element) { + { + var type = element.type; + if (type === null || type === void 0 || typeof type === "string") { + return; + } + var propTypes; + if (typeof type === "function") { + propTypes = type.propTypes; + } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + if (propTypes) { + var name = getComponentNameFromType(type); + checkPropTypes(propTypes, element.props, "prop", name, element); + } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; + var _name = getComponentNameFromType(type); + error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown"); + } + if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) { + error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead."); + } + } + } + function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (key !== "children" && key !== "key") { + setCurrentlyValidatingElement$1(fragment); + error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key); + setCurrentlyValidatingElement$1(null); + break; + } + } + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + error("Invalid attribute `ref` supplied to `React.Fragment`."); + setCurrentlyValidatingElement$1(null); + } + } + } + function createElementWithValidation(type, props, children) { + var validType = isValidElementType(type); + if (!validType) { + var info = ""; + if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) { + info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports."; + } + var sourceInfo = getSourceInfoErrorAddendumForProps(props); + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + var typeString; + if (type === null) { + typeString = "null"; + } else if (isArray(type)) { + typeString = "array"; + } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />"; + info = " Did you accidentally export a JSX literal instead of a component?"; + } else { + typeString = typeof type; + } + { + error("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info); + } + } + var element = createElement.apply(this, arguments); + if (element == null) { + return element; + } + if (validType) { + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], type); + } + } + if (type === REACT_FRAGMENT_TYPE) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + return element; + } + var didWarnAboutDeprecatedCreateFactory = false; + function createFactoryWithValidation(type) { + var validatedFactory = createElementWithValidation.bind(null, type); + validatedFactory.type = type; + { + if (!didWarnAboutDeprecatedCreateFactory) { + didWarnAboutDeprecatedCreateFactory = true; + warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead."); + } + Object.defineProperty(validatedFactory, "type", { + enumerable: false, + get: function() { + warn("Factory.type is deprecated. Access the class directly before passing it to createFactory."); + Object.defineProperty(this, "type", { + value: type + }); + return type; + } + }); + } + return validatedFactory; + } + function cloneElementWithValidation(element, props, children) { + var newElement = cloneElement.apply(this, arguments); + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], newElement.type); + } + validatePropTypes(newElement); + return newElement; + } + function startTransition(scope, options) { + var prevTransition = ReactCurrentBatchConfig.transition; + ReactCurrentBatchConfig.transition = {}; + var currentTransition = ReactCurrentBatchConfig.transition; + { + ReactCurrentBatchConfig.transition._updatedFibers = new Set(); + } + try { + scope(); + } finally { + ReactCurrentBatchConfig.transition = prevTransition; + { + if (prevTransition === null && currentTransition._updatedFibers) { + var updatedFibersCount = currentTransition._updatedFibers.size; + if (updatedFibersCount > 10) { + warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."); + } + currentTransition._updatedFibers.clear(); + } + } + } + } + var didWarnAboutMessageChannel = false; + var enqueueTaskImpl = null; + function enqueueTask(task) { + if (enqueueTaskImpl === null) { + try { + var requireString = ("require" + Math.random()).slice(0, 7); + var nodeRequire = module && module[requireString]; + enqueueTaskImpl = nodeRequire.call(module, "timers").setImmediate; + } catch (_err) { + enqueueTaskImpl = function(callback) { + { + if (didWarnAboutMessageChannel === false) { + didWarnAboutMessageChannel = true; + if (typeof MessageChannel === "undefined") { + error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."); + } + } + } + var channel = new MessageChannel(); + channel.port1.onmessage = callback; + channel.port2.postMessage(void 0); + }; + } + } + return enqueueTaskImpl(task); + } + var actScopeDepth = 0; + var didWarnNoAwaitAct = false; + function act(callback) { + { + var prevActScopeDepth = actScopeDepth; + actScopeDepth++; + if (ReactCurrentActQueue.current === null) { + ReactCurrentActQueue.current = []; + } + var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy; + var result; + try { + ReactCurrentActQueue.isBatchingLegacy = true; + result = callback(); + if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) { + var queue = ReactCurrentActQueue.current; + if (queue !== null) { + ReactCurrentActQueue.didScheduleLegacyUpdate = false; + flushActQueue(queue); + } + } + } catch (error2) { + popActScope(prevActScopeDepth); + throw error2; + } finally { + ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy; + } + if (result !== null && typeof result === "object" && typeof result.then === "function") { + var thenableResult = result; + var wasAwaited = false; + var thenable = { + then: function(resolve, reject) { + wasAwaited = true; + thenableResult.then(function(returnValue2) { + popActScope(prevActScopeDepth); + if (actScopeDepth === 0) { + recursivelyFlushAsyncActWork(returnValue2, resolve, reject); + } else { + resolve(returnValue2); + } + }, function(error2) { + popActScope(prevActScopeDepth); + reject(error2); + }); + } + }; + { + if (!didWarnNoAwaitAct && typeof Promise !== "undefined") { + Promise.resolve().then(function() { + }).then(function() { + if (!wasAwaited) { + didWarnNoAwaitAct = true; + error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"); + } + }); + } + } + return thenable; + } else { + var returnValue = result; + popActScope(prevActScopeDepth); + if (actScopeDepth === 0) { + var _queue = ReactCurrentActQueue.current; + if (_queue !== null) { + flushActQueue(_queue); + ReactCurrentActQueue.current = null; + } + var _thenable = { + then: function(resolve, reject) { + if (ReactCurrentActQueue.current === null) { + ReactCurrentActQueue.current = []; + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } else { + resolve(returnValue); + } + } + }; + return _thenable; + } else { + var _thenable2 = { + then: function(resolve, reject) { + resolve(returnValue); + } + }; + return _thenable2; + } + } + } + } + function popActScope(prevActScopeDepth) { + { + if (prevActScopeDepth !== actScopeDepth - 1) { + error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "); + } + actScopeDepth = prevActScopeDepth; + } + } + function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { + { + var queue = ReactCurrentActQueue.current; + if (queue !== null) { + try { + flushActQueue(queue); + enqueueTask(function() { + if (queue.length === 0) { + ReactCurrentActQueue.current = null; + resolve(returnValue); + } else { + recursivelyFlushAsyncActWork(returnValue, resolve, reject); + } + }); + } catch (error2) { + reject(error2); + } + } else { + resolve(returnValue); + } + } + } + var isFlushing = false; + function flushActQueue(queue) { + { + if (!isFlushing) { + isFlushing = true; + var i = 0; + try { + for (; i < queue.length; i++) { + var callback = queue[i]; + do { + callback = callback(true); + } while (callback !== null); + } + queue.length = 0; + } catch (error2) { + queue = queue.slice(i + 1); + throw error2; + } finally { + isFlushing = false; + } + } + } + } + var createElement$1 = createElementWithValidation; + var cloneElement$1 = cloneElementWithValidation; + var createFactory = createFactoryWithValidation; + var Children = { + map: mapChildren, + forEach: forEachChildren, + count: countChildren, + toArray, + only: onlyChild + }; + exports.Children = Children; + exports.Component = Component; + exports.Fragment = REACT_FRAGMENT_TYPE; + exports.Profiler = REACT_PROFILER_TYPE; + exports.PureComponent = PureComponent; + exports.StrictMode = REACT_STRICT_MODE_TYPE; + exports.Suspense = REACT_SUSPENSE_TYPE; + exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals; + exports.cloneElement = cloneElement$1; + exports.createContext = createContext; + exports.createElement = createElement$1; + exports.createFactory = createFactory; + exports.createRef = createRef; + exports.forwardRef = forwardRef; + exports.isValidElement = isValidElement; + exports.lazy = lazy; + exports.memo = memo; + exports.startTransition = startTransition; + exports.unstable_act = act; + exports.useCallback = useCallback; + exports.useContext = useContext; + exports.useDebugValue = useDebugValue; + exports.useDeferredValue = useDeferredValue; + exports.useEffect = useEffect; + exports.useId = useId; + exports.useImperativeHandle = useImperativeHandle; + exports.useInsertionEffect = useInsertionEffect; + exports.useLayoutEffect = useLayoutEffect; + exports.useMemo = useMemo; + exports.useReducer = useReducer; + exports.useRef = useRef; + exports.useState = useState; + exports.useSyncExternalStore = useSyncExternalStore; + exports.useTransition = useTransition; + exports.version = ReactVersion; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + } + })(); + } + }); + + // node_modules/react/index.js + var require_react = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_react_development(); + } + }); + + // node_modules/scheduler/cjs/scheduler.development.js + var require_scheduler_development = __commonJS((exports) => { + /** + * @license React + * scheduler.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + "use strict"; + if (true) { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var enableSchedulerDebugging = false; + var enableProfiling = false; + var frameYieldMs = 5; + function push(heap, node) { + var index = heap.length; + heap.push(node); + siftUp(heap, node, index); + } + function peek(heap) { + return heap.length === 0 ? null : heap[0]; + } + function pop(heap) { + if (heap.length === 0) { + return null; + } + var first = heap[0]; + var last = heap.pop(); + if (last !== first) { + heap[0] = last; + siftDown(heap, last, 0); + } + return first; + } + function siftUp(heap, node, i) { + var index = i; + while (index > 0) { + var parentIndex = index - 1 >>> 1; + var parent = heap[parentIndex]; + if (compare(parent, node) > 0) { + heap[parentIndex] = node; + heap[index] = parent; + index = parentIndex; + } else { + return; + } + } + } + function siftDown(heap, node, i) { + var index = i; + var length = heap.length; + var halfLength = length >>> 1; + while (index < halfLength) { + var leftIndex = (index + 1) * 2 - 1; + var left = heap[leftIndex]; + var rightIndex = leftIndex + 1; + var right = heap[rightIndex]; + if (compare(left, node) < 0) { + if (rightIndex < length && compare(right, left) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + heap[index] = left; + heap[leftIndex] = node; + index = leftIndex; + } + } else if (rightIndex < length && compare(right, node) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + return; + } + } + } + function compare(a, b) { + var diff = a.sortIndex - b.sortIndex; + return diff !== 0 ? diff : a.id - b.id; + } + var ImmediatePriority = 1; + var UserBlockingPriority = 2; + var NormalPriority = 3; + var LowPriority = 4; + var IdlePriority = 5; + function markTaskErrored(task, ms) { + } + var hasPerformanceNow = typeof performance === "object" && typeof performance.now === "function"; + if (hasPerformanceNow) { + var localPerformance = performance; + exports.unstable_now = function() { + return localPerformance.now(); + }; + } else { + var localDate = Date; + var initialTime = localDate.now(); + exports.unstable_now = function() { + return localDate.now() - initialTime; + }; + } + var maxSigned31BitInt = 1073741823; + var IMMEDIATE_PRIORITY_TIMEOUT = -1; + var USER_BLOCKING_PRIORITY_TIMEOUT = 250; + var NORMAL_PRIORITY_TIMEOUT = 5e3; + var LOW_PRIORITY_TIMEOUT = 1e4; + var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; + var taskQueue = []; + var timerQueue = []; + var taskIdCounter = 1; + var currentTask = null; + var currentPriorityLevel = NormalPriority; + var isPerformingWork = false; + var isHostCallbackScheduled = false; + var isHostTimeoutScheduled = false; + var localSetTimeout = typeof setTimeout === "function" ? setTimeout : null; + var localClearTimeout = typeof clearTimeout === "function" ? clearTimeout : null; + var localSetImmediate = typeof setImmediate !== "undefined" ? setImmediate : null; + var isInputPending = typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null; + function advanceTimers(currentTime) { + var timer = peek(timerQueue); + while (timer !== null) { + if (timer.callback === null) { + pop(timerQueue); + } else if (timer.startTime <= currentTime) { + pop(timerQueue); + timer.sortIndex = timer.expirationTime; + push(taskQueue, timer); + } else { + return; + } + timer = peek(timerQueue); + } + } + function handleTimeout(currentTime) { + isHostTimeoutScheduled = false; + advanceTimers(currentTime); + if (!isHostCallbackScheduled) { + if (peek(taskQueue) !== null) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + } + } + } + function flushWork(hasTimeRemaining, initialTime2) { + isHostCallbackScheduled = false; + if (isHostTimeoutScheduled) { + isHostTimeoutScheduled = false; + cancelHostTimeout(); + } + isPerformingWork = true; + var previousPriorityLevel = currentPriorityLevel; + try { + if (enableProfiling) { + try { + return workLoop(hasTimeRemaining, initialTime2); + } catch (error) { + if (currentTask !== null) { + var currentTime = exports.unstable_now(); + markTaskErrored(currentTask, currentTime); + currentTask.isQueued = false; + } + throw error; + } + } else { + return workLoop(hasTimeRemaining, initialTime2); + } + } finally { + currentTask = null; + currentPriorityLevel = previousPriorityLevel; + isPerformingWork = false; + } + } + function workLoop(hasTimeRemaining, initialTime2) { + var currentTime = initialTime2; + advanceTimers(currentTime); + currentTask = peek(taskQueue); + while (currentTask !== null && !enableSchedulerDebugging) { + if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) { + break; + } + var callback = currentTask.callback; + if (typeof callback === "function") { + currentTask.callback = null; + currentPriorityLevel = currentTask.priorityLevel; + var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; + var continuationCallback = callback(didUserCallbackTimeout); + currentTime = exports.unstable_now(); + if (typeof continuationCallback === "function") { + currentTask.callback = continuationCallback; + } else { + if (currentTask === peek(taskQueue)) { + pop(taskQueue); + } + } + advanceTimers(currentTime); + } else { + pop(taskQueue); + } + currentTask = peek(taskQueue); + } + if (currentTask !== null) { + return true; + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + return false; + } + } + function unstable_runWithPriority(priorityLevel, eventHandler) { + switch (priorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + case LowPriority: + case IdlePriority: + break; + default: + priorityLevel = NormalPriority; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + function unstable_next(eventHandler) { + var priorityLevel; + switch (currentPriorityLevel) { + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + priorityLevel = NormalPriority; + break; + default: + priorityLevel = currentPriorityLevel; + break; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + } + function unstable_wrapCallback(callback) { + var parentPriorityLevel = currentPriorityLevel; + return function() { + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = parentPriorityLevel; + try { + return callback.apply(this, arguments); + } finally { + currentPriorityLevel = previousPriorityLevel; + } + }; + } + function unstable_scheduleCallback(priorityLevel, callback, options) { + var currentTime = exports.unstable_now(); + var startTime2; + if (typeof options === "object" && options !== null) { + var delay = options.delay; + if (typeof delay === "number" && delay > 0) { + startTime2 = currentTime + delay; + } else { + startTime2 = currentTime; + } + } else { + startTime2 = currentTime; + } + var timeout; + switch (priorityLevel) { + case ImmediatePriority: + timeout = IMMEDIATE_PRIORITY_TIMEOUT; + break; + case UserBlockingPriority: + timeout = USER_BLOCKING_PRIORITY_TIMEOUT; + break; + case IdlePriority: + timeout = IDLE_PRIORITY_TIMEOUT; + break; + case LowPriority: + timeout = LOW_PRIORITY_TIMEOUT; + break; + case NormalPriority: + default: + timeout = NORMAL_PRIORITY_TIMEOUT; + break; + } + var expirationTime = startTime2 + timeout; + var newTask = { + id: taskIdCounter++, + callback, + priorityLevel, + startTime: startTime2, + expirationTime, + sortIndex: -1 + }; + if (startTime2 > currentTime) { + newTask.sortIndex = startTime2; + push(timerQueue, newTask); + if (peek(taskQueue) === null && newTask === peek(timerQueue)) { + if (isHostTimeoutScheduled) { + cancelHostTimeout(); + } else { + isHostTimeoutScheduled = true; + } + requestHostTimeout(handleTimeout, startTime2 - currentTime); + } + } else { + newTask.sortIndex = expirationTime; + push(taskQueue, newTask); + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + return newTask; + } + function unstable_pauseExecution() { + } + function unstable_continueExecution() { + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + function unstable_getFirstCallbackNode() { + return peek(taskQueue); + } + function unstable_cancelCallback(task) { + task.callback = null; + } + function unstable_getCurrentPriorityLevel() { + return currentPriorityLevel; + } + var isMessageLoopRunning = false; + var scheduledHostCallback = null; + var taskTimeoutID = -1; + var frameInterval = frameYieldMs; + var startTime = -1; + function shouldYieldToHost() { + var timeElapsed = exports.unstable_now() - startTime; + if (timeElapsed < frameInterval) { + return false; + } + return true; + } + function requestPaint() { + } + function forceFrameRate(fps) { + if (fps < 0 || fps > 125) { + console["error"]("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"); + return; + } + if (fps > 0) { + frameInterval = Math.floor(1e3 / fps); + } else { + frameInterval = frameYieldMs; + } + } + var performWorkUntilDeadline = function() { + if (scheduledHostCallback !== null) { + var currentTime = exports.unstable_now(); + startTime = currentTime; + var hasTimeRemaining = true; + var hasMoreWork = true; + try { + hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime); + } finally { + if (hasMoreWork) { + schedulePerformWorkUntilDeadline(); + } else { + isMessageLoopRunning = false; + scheduledHostCallback = null; + } + } + } else { + isMessageLoopRunning = false; + } + }; + var schedulePerformWorkUntilDeadline; + if (typeof localSetImmediate === "function") { + schedulePerformWorkUntilDeadline = function() { + localSetImmediate(performWorkUntilDeadline); + }; + } else if (typeof MessageChannel !== "undefined") { + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = performWorkUntilDeadline; + schedulePerformWorkUntilDeadline = function() { + port.postMessage(null); + }; + } else { + schedulePerformWorkUntilDeadline = function() { + localSetTimeout(performWorkUntilDeadline, 0); + }; + } + function requestHostCallback(callback) { + scheduledHostCallback = callback; + if (!isMessageLoopRunning) { + isMessageLoopRunning = true; + schedulePerformWorkUntilDeadline(); + } + } + function requestHostTimeout(callback, ms) { + taskTimeoutID = localSetTimeout(function() { + callback(exports.unstable_now()); + }, ms); + } + function cancelHostTimeout() { + localClearTimeout(taskTimeoutID); + taskTimeoutID = -1; + } + var unstable_requestPaint = requestPaint; + var unstable_Profiling = null; + exports.unstable_IdlePriority = IdlePriority; + exports.unstable_ImmediatePriority = ImmediatePriority; + exports.unstable_LowPriority = LowPriority; + exports.unstable_NormalPriority = NormalPriority; + exports.unstable_Profiling = unstable_Profiling; + exports.unstable_UserBlockingPriority = UserBlockingPriority; + exports.unstable_cancelCallback = unstable_cancelCallback; + exports.unstable_continueExecution = unstable_continueExecution; + exports.unstable_forceFrameRate = forceFrameRate; + exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; + exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; + exports.unstable_next = unstable_next; + exports.unstable_pauseExecution = unstable_pauseExecution; + exports.unstable_requestPaint = unstable_requestPaint; + exports.unstable_runWithPriority = unstable_runWithPriority; + exports.unstable_scheduleCallback = unstable_scheduleCallback; + exports.unstable_shouldYield = shouldYieldToHost; + exports.unstable_wrapCallback = unstable_wrapCallback; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); + } + })(); + } + }); + + // node_modules/scheduler/index.js + var require_scheduler = __commonJS((exports, module) => { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_scheduler_development(); + } + }); + + // node_modules/react-dom/cjs/react-dom.development.js + var require_react_dom_development = __commonJS((exports) => { + /** + * @license React + * react-dom.development.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + "use strict"; + if (true) { + (function() { + "use strict"; + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") { + __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); + } + var React = require_react(); + var Scheduler = require_scheduler(); + var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + var suppressWarning = false; + function setSuppressWarning(newSuppressWarning) { + { + suppressWarning = newSuppressWarning; + } + } + function warn(format) { + { + if (!suppressWarning) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + printWarning("warn", format, args); + } + } + } + function error(format) { + { + if (!suppressWarning) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + } + } + function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame2.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([stack]); + } + var argsWithFormat = args.map(function(item) { + return String(item); + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + } + var FunctionComponent = 0; + var ClassComponent = 1; + var IndeterminateComponent = 2; + var HostRoot = 3; + var HostPortal = 4; + var HostComponent = 5; + var HostText = 6; + var Fragment = 7; + var Mode = 8; + var ContextConsumer = 9; + var ContextProvider = 10; + var ForwardRef = 11; + var Profiler = 12; + var SuspenseComponent = 13; + var MemoComponent = 14; + var SimpleMemoComponent = 15; + var LazyComponent = 16; + var IncompleteClassComponent = 17; + var DehydratedFragment = 18; + var SuspenseListComponent = 19; + var ScopeComponent = 21; + var OffscreenComponent = 22; + var LegacyHiddenComponent = 23; + var CacheComponent = 24; + var TracingMarkerComponent = 25; + var enableClientRenderFallbackOnTextMismatch = true; + var enableNewReconciler = false; + var enableLazyContextPropagation = false; + var enableLegacyHidden = false; + var enableSuspenseAvoidThisFallback = false; + var disableCommentsAsDOMContainers = true; + var enableCustomElementPropertySupport = false; + var warnAboutStringRefs = false; + var enableSchedulingProfiler = true; + var enableProfilerTimer = true; + var enableProfilerCommitHooks = true; + var allNativeEvents = new Set(); + var registrationNameDependencies = {}; + var possibleRegistrationNames = {}; + function registerTwoPhaseEvent(registrationName, dependencies) { + registerDirectEvent(registrationName, dependencies); + registerDirectEvent(registrationName + "Capture", dependencies); + } + function registerDirectEvent(registrationName, dependencies) { + { + if (registrationNameDependencies[registrationName]) { + error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName); + } + } + registrationNameDependencies[registrationName] = dependencies; + { + var lowerCasedName = registrationName.toLowerCase(); + possibleRegistrationNames[lowerCasedName] = registrationName; + if (registrationName === "onDoubleClick") { + possibleRegistrationNames.ondblclick = registrationName; + } + } + for (var i = 0; i < dependencies.length; i++) { + allNativeEvents.add(dependencies[i]); + } + } + var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined"); + var hasOwnProperty = Object.prototype.hasOwnProperty; + function typeName(value) { + { + var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag; + var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; + return type; + } + } + function willCoercionThrow(value) { + { + try { + testStringCoercion(value); + return false; + } catch (e) { + return true; + } + } + } + function testStringCoercion(value) { + return "" + value; + } + function checkAttributeStringCoercion(value, attributeName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before before using it here.", attributeName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkKeyStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + function checkPropStringCoercion(value, propName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` prop is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkCSSPropertyStringCoercion(value, propName) { + { + if (willCoercionThrow(value)) { + error("The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(value)); + return testStringCoercion(value); + } + } + } + function checkHtmlStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + function checkFormFieldValueStringCoercion(value) { + { + if (willCoercionThrow(value)) { + error("Form field values (value, checked, defaultValue, or defaultChecked props) must be strings, not %s. This value must be coerced to a string before before using it here.", typeName(value)); + return testStringCoercion(value); + } + } + } + var RESERVED = 0; + var STRING = 1; + var BOOLEANISH_STRING = 2; + var BOOLEAN = 3; + var OVERLOADED_BOOLEAN = 4; + var NUMERIC = 5; + var POSITIVE_NUMERIC = 6; + var ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD"; + var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040"; + var VALID_ATTRIBUTE_NAME_REGEX = new RegExp("^[" + ATTRIBUTE_NAME_START_CHAR + "][" + ATTRIBUTE_NAME_CHAR + "]*$"); + var illegalAttributeNameCache = {}; + var validatedAttributeNameCache = {}; + function isAttributeNameSafe(attributeName) { + if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) { + return true; + } + if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) { + return false; + } + if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) { + validatedAttributeNameCache[attributeName] = true; + return true; + } + illegalAttributeNameCache[attributeName] = true; + { + error("Invalid attribute name: `%s`", attributeName); + } + return false; + } + function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null) { + return propertyInfo.type === RESERVED; + } + if (isCustomComponentTag) { + return false; + } + if (name.length > 2 && (name[0] === "o" || name[0] === "O") && (name[1] === "n" || name[1] === "N")) { + return true; + } + return false; + } + function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null && propertyInfo.type === RESERVED) { + return false; + } + switch (typeof value) { + case "function": + case "symbol": + return true; + case "boolean": { + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + return !propertyInfo.acceptsBooleans; + } else { + var prefix2 = name.toLowerCase().slice(0, 5); + return prefix2 !== "data-" && prefix2 !== "aria-"; + } + } + default: + return false; + } + } + function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) { + if (value === null || typeof value === "undefined") { + return true; + } + if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) { + return true; + } + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + switch (propertyInfo.type) { + case BOOLEAN: + return !value; + case OVERLOADED_BOOLEAN: + return value === false; + case NUMERIC: + return isNaN(value); + case POSITIVE_NUMERIC: + return isNaN(value) || value < 1; + } + } + return false; + } + function getPropertyInfo(name) { + return properties.hasOwnProperty(name) ? properties[name] : null; + } + function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL2, removeEmptyString) { + this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN; + this.attributeName = attributeName; + this.attributeNamespace = attributeNamespace; + this.mustUseProperty = mustUseProperty; + this.propertyName = name; + this.type = type; + this.sanitizeURL = sanitizeURL2; + this.removeEmptyString = removeEmptyString; + } + var properties = {}; + var reservedProps = [ + "children", + "dangerouslySetInnerHTML", + "defaultValue", + "defaultChecked", + "innerHTML", + "suppressContentEditableWarning", + "suppressHydrationWarning", + "style" + ]; + reservedProps.forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, RESERVED, false, name, null, false, false); + }); + [["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(_ref) { + var name = _ref[0], attributeName = _ref[1]; + properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, null, false, false); + }); + ["contentEditable", "draggable", "spellCheck", "value"].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, name.toLowerCase(), null, false, false); + }); + ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, name, null, false, false); + }); + [ + "allowFullScreen", + "async", + "autoFocus", + "autoPlay", + "controls", + "default", + "defer", + "disabled", + "disablePictureInPicture", + "disableRemotePlayback", + "formNoValidate", + "hidden", + "loop", + "noModule", + "noValidate", + "open", + "playsInline", + "readOnly", + "required", + "reversed", + "scoped", + "seamless", + "itemScope" + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, name.toLowerCase(), null, false, false); + }); + [ + "checked", + "multiple", + "muted", + "selected" + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, name, null, false, false); + }); + [ + "capture", + "download" + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, name, null, false, false); + }); + [ + "cols", + "rows", + "size", + "span" + ].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, name, null, false, false); + }); + ["rowSpan", "start"].forEach(function(name) { + properties[name] = new PropertyInfoRecord(name, NUMERIC, false, name.toLowerCase(), null, false, false); + }); + var CAMELIZE = /[\-\:]([a-z])/g; + var capitalize = function(token) { + return token[1].toUpperCase(); + }; + [ + "accent-height", + "alignment-baseline", + "arabic-form", + "baseline-shift", + "cap-height", + "clip-path", + "clip-rule", + "color-interpolation", + "color-interpolation-filters", + "color-profile", + "color-rendering", + "dominant-baseline", + "enable-background", + "fill-opacity", + "fill-rule", + "flood-color", + "flood-opacity", + "font-family", + "font-size", + "font-size-adjust", + "font-stretch", + "font-style", + "font-variant", + "font-weight", + "glyph-name", + "glyph-orientation-horizontal", + "glyph-orientation-vertical", + "horiz-adv-x", + "horiz-origin-x", + "image-rendering", + "letter-spacing", + "lighting-color", + "marker-end", + "marker-mid", + "marker-start", + "overline-position", + "overline-thickness", + "paint-order", + "panose-1", + "pointer-events", + "rendering-intent", + "shape-rendering", + "stop-color", + "stop-opacity", + "strikethrough-position", + "strikethrough-thickness", + "stroke-dasharray", + "stroke-dashoffset", + "stroke-linecap", + "stroke-linejoin", + "stroke-miterlimit", + "stroke-opacity", + "stroke-width", + "text-anchor", + "text-decoration", + "text-rendering", + "underline-position", + "underline-thickness", + "unicode-bidi", + "unicode-range", + "units-per-em", + "v-alphabetic", + "v-hanging", + "v-ideographic", + "v-mathematical", + "vector-effect", + "vert-adv-y", + "vert-origin-x", + "vert-origin-y", + "word-spacing", + "writing-mode", + "xmlns:xlink", + "x-height" + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, null, false, false); + }); + [ + "xlink:actuate", + "xlink:arcrole", + "xlink:role", + "xlink:show", + "xlink:title", + "xlink:type" + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, "http://www.w3.org/1999/xlink", false, false); + }); + [ + "xml:base", + "xml:lang", + "xml:space" + ].forEach(function(attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, attributeName, "http://www.w3.org/XML/1998/namespace", false, false); + }); + ["tabIndex", "crossOrigin"].forEach(function(attributeName) { + properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, attributeName.toLowerCase(), null, false, false); + }); + var xlinkHref = "xlinkHref"; + properties[xlinkHref] = new PropertyInfoRecord("xlinkHref", STRING, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false); + ["src", "href", "action", "formAction"].forEach(function(attributeName) { + properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, attributeName.toLowerCase(), null, true, true); + }); + var isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i; + var didWarn = false; + function sanitizeURL(url) { + { + if (!didWarn && isJavaScriptProtocol.test(url)) { + didWarn = true; + error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML try using dangerouslySetInnerHTML instead. React was passed %s.", JSON.stringify(url)); + } + } + } + function getValueForProperty(node, name, expected, propertyInfo) { + { + if (propertyInfo.mustUseProperty) { + var propertyName = propertyInfo.propertyName; + return node[propertyName]; + } else { + { + checkAttributeStringCoercion(expected, name); + } + if (propertyInfo.sanitizeURL) { + sanitizeURL("" + expected); + } + var attributeName = propertyInfo.attributeName; + var stringValue = null; + if (propertyInfo.type === OVERLOADED_BOOLEAN) { + if (node.hasAttribute(attributeName)) { + var value = node.getAttribute(attributeName); + if (value === "") { + return true; + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return value; + } + if (value === "" + expected) { + return expected; + } + return value; + } + } else if (node.hasAttribute(attributeName)) { + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return node.getAttribute(attributeName); + } + if (propertyInfo.type === BOOLEAN) { + return expected; + } + stringValue = node.getAttribute(attributeName); + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return stringValue === null ? expected : stringValue; + } else if (stringValue === "" + expected) { + return expected; + } else { + return stringValue; + } + } + } + } + function getValueForAttribute(node, name, expected, isCustomComponentTag) { + { + if (!isAttributeNameSafe(name)) { + return; + } + if (!node.hasAttribute(name)) { + return expected === void 0 ? void 0 : null; + } + var value = node.getAttribute(name); + { + checkAttributeStringCoercion(expected, name); + } + if (value === "" + expected) { + return expected; + } + return value; + } + } + function setValueForProperty(node, name, value, isCustomComponentTag) { + var propertyInfo = getPropertyInfo(name); + if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) { + return; + } + if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) { + value = null; + } + if (isCustomComponentTag || propertyInfo === null) { + if (isAttributeNameSafe(name)) { + var _attributeName = name; + if (value === null) { + node.removeAttribute(_attributeName); + } else { + { + checkAttributeStringCoercion(value, name); + } + node.setAttribute(_attributeName, "" + value); + } + } + return; + } + var mustUseProperty = propertyInfo.mustUseProperty; + if (mustUseProperty) { + var propertyName = propertyInfo.propertyName; + if (value === null) { + var type = propertyInfo.type; + node[propertyName] = type === BOOLEAN ? false : ""; + } else { + node[propertyName] = value; + } + return; + } + var attributeName = propertyInfo.attributeName, attributeNamespace = propertyInfo.attributeNamespace; + if (value === null) { + node.removeAttribute(attributeName); + } else { + var _type = propertyInfo.type; + var attributeValue; + if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) { + attributeValue = ""; + } else { + { + { + checkAttributeStringCoercion(value, attributeName); + } + attributeValue = "" + value; + } + if (propertyInfo.sanitizeURL) { + sanitizeURL(attributeValue.toString()); + } + } + if (attributeNamespace) { + node.setAttributeNS(attributeNamespace, attributeName, attributeValue); + } else { + node.setAttribute(attributeName, attributeValue); + } + } + } + var REACT_ELEMENT_TYPE = Symbol.for("react.element"); + var REACT_PORTAL_TYPE = Symbol.for("react.portal"); + var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"); + var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"); + var REACT_PROFILER_TYPE = Symbol.for("react.profiler"); + var REACT_PROVIDER_TYPE = Symbol.for("react.provider"); + var REACT_CONTEXT_TYPE = Symbol.for("react.context"); + var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"); + var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"); + var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"); + var REACT_MEMO_TYPE = Symbol.for("react.memo"); + var REACT_LAZY_TYPE = Symbol.for("react.lazy"); + var REACT_SCOPE_TYPE = Symbol.for("react.scope"); + var REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"); + var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"); + var REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"); + var REACT_CACHE_TYPE = Symbol.for("react.cache"); + var REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"); + var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = "@@iterator"; + function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== "object") { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === "function") { + return maybeIterator; + } + return null; + } + var assign = Object.assign; + var disabledDepth = 0; + var prevLog; + var prevInfo; + var prevWarn; + var prevError; + var prevGroup; + var prevGroupCollapsed; + var prevGroupEnd; + function disabledLog() { + } + disabledLog.__reactDisabledLog = true; + function disableLogs() { + { + if (disabledDepth === 0) { + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + } + disabledDepth++; + } + } + function reenableLogs() { + { + disabledDepth--; + if (disabledDepth === 0) { + var props = { + configurable: true, + enumerable: true, + writable: true + }; + Object.defineProperties(console, { + log: assign({}, props, { + value: prevLog + }), + info: assign({}, props, { + value: prevInfo + }), + warn: assign({}, props, { + value: prevWarn + }), + error: assign({}, props, { + value: prevError + }), + group: assign({}, props, { + value: prevGroup + }), + groupCollapsed: assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: assign({}, props, { + value: prevGroupEnd + }) + }); + } + if (disabledDepth < 0) { + error("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + } + var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher; + var prefix; + function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === void 0) { + try { + throw Error(); + } catch (x) { + var match = x.stack.trim().match(/\n( *(at )?)/); + prefix = match && match[1] || ""; + } + } + return "\n" + prefix + name; + } + } + var reentry = false; + var componentFrameCache; + { + var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); + } + function describeNativeComponentFrame(fn, construct) { + if (!fn || reentry) { + return ""; + } + { + var frame = componentFrameCache.get(fn); + if (frame !== void 0) { + return frame; + } + } + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var previousDispatcher; + { + previousDispatcher = ReactCurrentDispatcher.current; + ReactCurrentDispatcher.current = null; + disableLogs(); + } + try { + if (construct) { + var Fake = function() { + throw Error(); + }; + Object.defineProperty(Fake.prototype, "props", { + set: function() { + throw Error(); + } + }); + if (typeof Reflect === "object" && Reflect.construct) { + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + fn(); + } + } catch (sample) { + if (sample && control && typeof sample.stack === "string") { + var sampleLines = sample.stack.split("\n"); + var controlLines = control.stack.split("\n"); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { + c--; + } + for (; s >= 1 && c >= 0; s--, c--) { + if (sampleLines[s] !== controlLines[c]) { + if (s !== 1 || c !== 1) { + do { + s--; + c--; + if (c < 0 || sampleLines[s] !== controlLines[c]) { + var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); + if (fn.displayName && _frame.includes("")) { + _frame = _frame.replace("", fn.displayName); + } + { + if (typeof fn === "function") { + componentFrameCache.set(fn, _frame); + } + } + return _frame; + } + } while (s >= 1 && c >= 0); + } + break; + } + } + } + } finally { + reentry = false; + { + ReactCurrentDispatcher.current = previousDispatcher; + reenableLogs(); + } + Error.prepareStackTrace = previousPrepareStackTrace; + } + var name = fn ? fn.displayName || fn.name : ""; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ""; + { + if (typeof fn === "function") { + componentFrameCache.set(fn, syntheticFrame); + } + } + return syntheticFrame; + } + function describeClassComponentFrame(ctor, source, ownerFn) { + { + return describeNativeComponentFrame(ctor, true); + } + } + function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + } + function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); + } + function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + if (type == null) { + return ""; + } + if (typeof type === "function") { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + if (typeof type === "string") { + return describeBuiltInComponentFrame(type); + } + switch (type) { + case REACT_SUSPENSE_TYPE: + return describeBuiltInComponentFrame("Suspense"); + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame("SuspenseList"); + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + case REACT_MEMO_TYPE: + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) { + } + } + } + } + return ""; + } + function describeFiber(fiber) { + var owner = fiber._debugOwner ? fiber._debugOwner.type : null; + var source = fiber._debugSource; + switch (fiber.tag) { + case HostComponent: + return describeBuiltInComponentFrame(fiber.type); + case LazyComponent: + return describeBuiltInComponentFrame("Lazy"); + case SuspenseComponent: + return describeBuiltInComponentFrame("Suspense"); + case SuspenseListComponent: + return describeBuiltInComponentFrame("SuspenseList"); + case FunctionComponent: + case IndeterminateComponent: + case SimpleMemoComponent: + return describeFunctionComponentFrame(fiber.type); + case ForwardRef: + return describeFunctionComponentFrame(fiber.type.render); + case ClassComponent: + return describeClassComponentFrame(fiber.type); + default: + return ""; + } + } + function getStackByFiberInDevAndProd(workInProgress2) { + try { + var info = ""; + var node = workInProgress2; + do { + info += describeFiber(node); + node = node.return; + } while (node); + return info; + } catch (x) { + return "\nError generating stack: " + x.message + "\n" + x.stack; + } + } + function getWrappedName(outerType, innerType, wrapperName) { + var displayName = outerType.displayName; + if (displayName) { + return displayName; + } + var functionName = innerType.displayName || innerType.name || ""; + return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName; + } + function getContextName(type) { + return type.displayName || "Context"; + } + function getComponentNameFromType(type) { + if (type == null) { + return null; + } + { + if (typeof type.tag === "number") { + error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."); + } + } + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + switch (type) { + case REACT_FRAGMENT_TYPE: + return "Fragment"; + case REACT_PORTAL_TYPE: + return "Portal"; + case REACT_PROFILER_TYPE: + return "Profiler"; + case REACT_STRICT_MODE_TYPE: + return "StrictMode"; + case REACT_SUSPENSE_TYPE: + return "Suspense"; + case REACT_SUSPENSE_LIST_TYPE: + return "SuspenseList"; + } + if (typeof type === "object") { + switch (type.$$typeof) { + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + ".Consumer"; + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + ".Provider"; + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, "ForwardRef"); + case REACT_MEMO_TYPE: + var outerName = type.displayName || null; + if (outerName !== null) { + return outerName; + } + return getComponentNameFromType(type.type) || "Memo"; + case REACT_LAZY_TYPE: { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return getComponentNameFromType(init(payload)); + } catch (x) { + return null; + } + } + } + } + return null; + } + function getWrappedName$1(outerType, innerType, wrapperName) { + var functionName = innerType.displayName || innerType.name || ""; + return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName); + } + function getContextName$1(type) { + return type.displayName || "Context"; + } + function getComponentNameFromFiber(fiber) { + var tag = fiber.tag, type = fiber.type; + switch (tag) { + case CacheComponent: + return "Cache"; + case ContextConsumer: + var context = type; + return getContextName$1(context) + ".Consumer"; + case ContextProvider: + var provider = type; + return getContextName$1(provider._context) + ".Provider"; + case DehydratedFragment: + return "DehydratedFragment"; + case ForwardRef: + return getWrappedName$1(type, type.render, "ForwardRef"); + case Fragment: + return "Fragment"; + case HostComponent: + return type; + case HostPortal: + return "Portal"; + case HostRoot: + return "Root"; + case HostText: + return "Text"; + case LazyComponent: + return getComponentNameFromType(type); + case Mode: + if (type === REACT_STRICT_MODE_TYPE) { + return "StrictMode"; + } + return "Mode"; + case OffscreenComponent: + return "Offscreen"; + case Profiler: + return "Profiler"; + case ScopeComponent: + return "Scope"; + case SuspenseComponent: + return "Suspense"; + case SuspenseListComponent: + return "SuspenseList"; + case TracingMarkerComponent: + return "TracingMarker"; + case ClassComponent: + case FunctionComponent: + case IncompleteClassComponent: + case IndeterminateComponent: + case MemoComponent: + case SimpleMemoComponent: + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + break; + } + return null; + } + var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; + var current = null; + var isRendering = false; + function getCurrentFiberOwnerNameInDevOrNull() { + { + if (current === null) { + return null; + } + var owner = current._debugOwner; + if (owner !== null && typeof owner !== "undefined") { + return getComponentNameFromFiber(owner); + } + } + return null; + } + function getCurrentFiberStackInDev() { + { + if (current === null) { + return ""; + } + return getStackByFiberInDevAndProd(current); + } + } + function resetCurrentFiber() { + { + ReactDebugCurrentFrame.getCurrentStack = null; + current = null; + isRendering = false; + } + } + function setCurrentFiber(fiber) { + { + ReactDebugCurrentFrame.getCurrentStack = fiber === null ? null : getCurrentFiberStackInDev; + current = fiber; + isRendering = false; + } + } + function getCurrentFiber() { + { + return current; + } + } + function setIsRendering(rendering) { + { + isRendering = rendering; + } + } + function toString(value) { + return "" + value; + } + function getToStringValue(value) { + switch (typeof value) { + case "boolean": + case "number": + case "string": + case "undefined": + return value; + case "object": + { + checkFormFieldValueStringCoercion(value); + } + return value; + default: + return ""; + } + } + var hasReadOnlyValue = { + button: true, + checkbox: true, + image: true, + hidden: true, + radio: true, + reset: true, + submit: true + }; + function checkControlledValueProps(tagName, props) { + { + if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) { + error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`."); + } + if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) { + error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`."); + } + } + } + function isCheckable(elem) { + var type = elem.type; + var nodeName = elem.nodeName; + return nodeName && nodeName.toLowerCase() === "input" && (type === "checkbox" || type === "radio"); + } + function getTracker(node) { + return node._valueTracker; + } + function detachTracker(node) { + node._valueTracker = null; + } + function getValueFromNode(node) { + var value = ""; + if (!node) { + return value; + } + if (isCheckable(node)) { + value = node.checked ? "true" : "false"; + } else { + value = node.value; + } + return value; + } + function trackValueOnNode(node) { + var valueField = isCheckable(node) ? "checked" : "value"; + var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField); + { + checkFormFieldValueStringCoercion(node[valueField]); + } + var currentValue = "" + node[valueField]; + if (node.hasOwnProperty(valueField) || typeof descriptor === "undefined" || typeof descriptor.get !== "function" || typeof descriptor.set !== "function") { + return; + } + var get2 = descriptor.get, set2 = descriptor.set; + Object.defineProperty(node, valueField, { + configurable: true, + get: function() { + return get2.call(this); + }, + set: function(value) { + { + checkFormFieldValueStringCoercion(value); + } + currentValue = "" + value; + set2.call(this, value); + } + }); + Object.defineProperty(node, valueField, { + enumerable: descriptor.enumerable + }); + var tracker = { + getValue: function() { + return currentValue; + }, + setValue: function(value) { + { + checkFormFieldValueStringCoercion(value); + } + currentValue = "" + value; + }, + stopTracking: function() { + detachTracker(node); + delete node[valueField]; + } + }; + return tracker; + } + function track(node) { + if (getTracker(node)) { + return; + } + node._valueTracker = trackValueOnNode(node); + } + function updateValueIfChanged(node) { + if (!node) { + return false; + } + var tracker = getTracker(node); + if (!tracker) { + return true; + } + var lastValue = tracker.getValue(); + var nextValue = getValueFromNode(node); + if (nextValue !== lastValue) { + tracker.setValue(nextValue); + return true; + } + return false; + } + function getActiveElement(doc) { + doc = doc || (typeof document !== "undefined" ? document : void 0); + if (typeof doc === "undefined") { + return null; + } + try { + return doc.activeElement || doc.body; + } catch (e) { + return doc.body; + } + } + var didWarnValueDefaultValue = false; + var didWarnCheckedDefaultChecked = false; + var didWarnControlledToUncontrolled = false; + var didWarnUncontrolledToControlled = false; + function isControlled(props) { + var usesChecked = props.type === "checkbox" || props.type === "radio"; + return usesChecked ? props.checked != null : props.value != null; + } + function getHostProps(element, props) { + var node = element; + var checked = props.checked; + var hostProps = assign({}, props, { + defaultChecked: void 0, + defaultValue: void 0, + value: void 0, + checked: checked != null ? checked : node._wrapperState.initialChecked + }); + return hostProps; + } + function initWrapperState(element, props) { + { + checkControlledValueProps("input", props); + if (props.checked !== void 0 && props.defaultChecked !== void 0 && !didWarnCheckedDefaultChecked) { + error("%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnCheckedDefaultChecked = true; + } + if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValueDefaultValue) { + error("%s contains an input of type %s with both value and defaultValue props. Input elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnValueDefaultValue = true; + } + } + var node = element; + var defaultValue = props.defaultValue == null ? "" : props.defaultValue; + node._wrapperState = { + initialChecked: props.checked != null ? props.checked : props.defaultChecked, + initialValue: getToStringValue(props.value != null ? props.value : defaultValue), + controlled: isControlled(props) + }; + } + function updateChecked(element, props) { + var node = element; + var checked = props.checked; + if (checked != null) { + setValueForProperty(node, "checked", checked, false); + } + } + function updateWrapper(element, props) { + var node = element; + { + var controlled = isControlled(props); + if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) { + error("A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnUncontrolledToControlled = true; + } + if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) { + error("A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnControlledToUncontrolled = true; + } + } + updateChecked(element, props); + var value = getToStringValue(props.value); + var type = props.type; + if (value != null) { + if (type === "number") { + if (value === 0 && node.value === "" || node.value != value) { + node.value = toString(value); + } + } else if (node.value !== toString(value)) { + node.value = toString(value); + } + } else if (type === "submit" || type === "reset") { + node.removeAttribute("value"); + return; + } + { + if (props.hasOwnProperty("value")) { + setDefaultValue(node, props.type, value); + } else if (props.hasOwnProperty("defaultValue")) { + setDefaultValue(node, props.type, getToStringValue(props.defaultValue)); + } + } + { + if (props.checked == null && props.defaultChecked != null) { + node.defaultChecked = !!props.defaultChecked; + } + } + } + function postMountWrapper(element, props, isHydrating2) { + var node = element; + if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) { + var type = props.type; + var isButton = type === "submit" || type === "reset"; + if (isButton && (props.value === void 0 || props.value === null)) { + return; + } + var initialValue = toString(node._wrapperState.initialValue); + if (!isHydrating2) { + { + if (initialValue !== node.value) { + node.value = initialValue; + } + } + } + { + node.defaultValue = initialValue; + } + } + var name = node.name; + if (name !== "") { + node.name = ""; + } + { + node.defaultChecked = !node.defaultChecked; + node.defaultChecked = !!node._wrapperState.initialChecked; + } + if (name !== "") { + node.name = name; + } + } + function restoreControlledState(element, props) { + var node = element; + updateWrapper(node, props); + updateNamedCousins(node, props); + } + function updateNamedCousins(rootNode, props) { + var name = props.name; + if (props.type === "radio" && name != null) { + var queryRoot = rootNode; + while (queryRoot.parentNode) { + queryRoot = queryRoot.parentNode; + } + { + checkAttributeStringCoercion(name, "name"); + } + var group = queryRoot.querySelectorAll("input[name=" + JSON.stringify("" + name) + '][type="radio"]'); + for (var i = 0; i < group.length; i++) { + var otherNode = group[i]; + if (otherNode === rootNode || otherNode.form !== rootNode.form) { + continue; + } + var otherProps = getFiberCurrentPropsFromNode(otherNode); + if (!otherProps) { + throw new Error("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported."); + } + updateValueIfChanged(otherNode); + updateWrapper(otherNode, otherProps); + } + } + } + function setDefaultValue(node, type, value) { + if (type !== "number" || getActiveElement(node.ownerDocument) !== node) { + if (value == null) { + node.defaultValue = toString(node._wrapperState.initialValue); + } else if (node.defaultValue !== toString(value)) { + node.defaultValue = toString(value); + } + } + } + var didWarnSelectedSetOnOption = false; + var didWarnInvalidChild = false; + var didWarnInvalidInnerHTML = false; + function validateProps(element, props) { + { + if (props.value == null) { + if (typeof props.children === "object" && props.children !== null) { + React.Children.forEach(props.children, function(child) { + if (child == null) { + return; + } + if (typeof child === "string" || typeof child === "number") { + return; + } + if (!didWarnInvalidChild) { + didWarnInvalidChild = true; + error("Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to